easy-file-system 5.0.73 → 5.0.75

package/lib/item/entry/drag/directoryName.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return DirectoryNameDragEntryItem;
+    }
+});
+const _easydraganddrop = require("easy-drag-and-drop");
+const _necessary = require("necessary");
+const _toggle = /*#__PURE__*/ _interop_require_default(require("../../../button/toggle"));
+const _drag = /*#__PURE__*/ _interop_require_default(require("../../../item/entry/drag"));
+const _directoryName = /*#__PURE__*/ _interop_require_default(require("../../../svg/directoryName"));
+const _directoryName1 = /*#__PURE__*/ _interop_require_default(require("../../../div/item/entry/drag/directoryName"));
+const _pathMap = require("../../../utilities/pathMap");
+const _entryTypes = require("../../../entryTypes");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const { concatenatePaths } = _necessary.pathUtilities;
+class DirectoryNameDragEntryItem extends _drag.default {
+    dragOverCustomHandler = (event, element, dragElement)=>{
+        const collapsed = this.isCollapsed();
+        if (collapsed) {
+            return;
+        }
+        const path = this.getPath(), explorer = this.getExplorer(), dragEntryItem = dragElement, markerEntryItem = this.retrieveMarkerEntryItem(), dragEntryItemName = dragEntryItem.getName();
+        let markerEntryItemPath = markerEntryItem.getPath(), markerEntryItemExplorer = markerEntryItem.getExplorer(), previousMarkerEntryItemPath = markerEntryItemPath, previousMarkerEntryItemExplorer = markerEntryItemExplorer; ///
+        markerEntryItemPath = concatenatePaths(path, dragEntryItemName);
+        markerEntryItemExplorer = explorer; ///
+        if (markerEntryItemExplorer !== previousMarkerEntryItemExplorer || markerEntryItemPath !== previousMarkerEntryItemPath) {
+            const dragEntryItemType = dragEntryItem.getType();
+            previousMarkerEntryItemExplorer.removeMarker();
+            markerEntryItemExplorer.addMarker(markerEntryItemPath, dragEntryItemType);
+        }
+    };
+    dropCustomHandler = (event, element, dragElement, aborted, done)=>{
+        const dragEntryItem = dragElement, markerEntryItem = this.retrieveMarkerEntryItem(), markerEntryItemExplorer = markerEntryItem.getExplorer();
+        if (aborted) {
+            markerEntryItemExplorer.removeMarker();
+            done();
+            return;
+        }
+        markerEntryItemExplorer.dropDragEntryItem(event, element, dragEntryItem, done);
+    };
+    doubleClick(event, element) {
+        let collapsed = this.isCollapsed();
+        collapsed = !collapsed;
+        collapsed ? this.collapse() : this.expand();
+    }
+    singleClick(event, element) {
+        this.expand();
+    }
+    isBefore(entryItem) {
+        let before;
+        const entryItemType = entryItem.getType();
+        switch(entryItemType){
+            case _entryTypes.FILE_NAME_DRAG_ENTRY_TYPE:
+            case _entryTypes.FILE_NAME_MARKER_ENTRY_TYPE:
+            case _entryTypes.DIRECTORY_NAME_MARKER_ENTRY_TYPE:
+                before = true;
+                break;
+            case _entryTypes.DIRECTORY_NAME_DRAG_ENTRY_TYPE:
+                const name = this.getName(), entryItemName = entryItem.getName();
+                before = name.localeCompare(entryItemName) < 0;
+                break;
+        }
+        return before;
+    }
+    isTopmost() {
+        const { topmost } = this.properties;
+        return topmost;
+    }
+    isCollapsed() {
+        const entriesListCollapsed = this.isEntriesListCollapsed(), collapsed = entriesListCollapsed; ///
+        return collapsed;
+    }
+    getReference() {
+        const explorer = this.getExplorer(), reference = explorer.getReference();
+        return reference;
+    }
+    getReferences() {
+        const explorer = this.getExplorer(), references = explorer.getReferences();
+        return references;
+    }
+    retrievePathMaps(sourceEntryPath, targetEntryPath, pathMaps) {
+        const name = this.getName(), pathMap = this.getPathMap(sourceEntryPath, targetEntryPath), nameSpanName = this.getNameSpanName();
+        pathMaps.push(pathMap);
+        sourceEntryPath = (0, _pathMap.adjustSourceEntryPath)(sourceEntryPath, name);
+        targetEntryPath = (0, _pathMap.adjustTargetEntryPath)(targetEntryPath, nameSpanName);
+        this.forEachDragEntryItem((dragEntryItem)=>{
+            dragEntryItem.retrievePathMaps(sourceEntryPath, targetEntryPath, pathMaps);
+        });
+    }
+    removeFromExplorer() {
+        const path = this.getPath(), explorer = this.getExplorer(), directoryPath = path; ///
+        explorer.removeDirectoryPath(directoryPath);
+    }
+    collapse() {
+        this.collapseEntriesList();
+        this.collapseToggleButton();
+    }
+    expand() {
+        this.expandEntriesList();
+        this.expandToggleButton();
+    }
+    didMount() {
+        const { collapsed } = this.properties;
+        collapsed ? this.collapse() : this.expand();
+        this.enableDrop();
+        this.onCustomDrop(this.dropCustomHandler);
+        this.onCustomDragOver(this.dragOverCustomHandler);
+        super.didMount();
+    }
+    willUnmount() {
+        this.disableDrop();
+        this.offCustomDrop(this.dropCustomHandler);
+        this.offCustomDragOver(this.dragOverCustomHandler);
+        super.willUnmount();
+    }
+    childElements() {
+        const { name } = this.properties, { NameSpan, ToggleButton, DirectoryNameSVG } = this.constructor, explorer = this.getExplorer(), EntriesList = explorer.getEntriesList();
+        return [
+            /*#__PURE__*/ React.createElement(_directoryName1.default, {
+                name: name,
+                explorer: explorer,
+                NameSpan: NameSpan,
+                ToggleButton: ToggleButton,
+                DirectoryNameSVG: DirectoryNameSVG
+            }),
+            /*#__PURE__*/ React.createElement(EntriesList, {
+                explorer: explorer
+            })
+        ];
+    }
+    static type = _entryTypes.DIRECTORY_NAME_DRAG_ENTRY_TYPE;
+    static ToggleButton = _toggle.default;
+    static DirectoryNameSVG = _directoryName.default;
+    static ignoredProperties = [
+        "topmost"
+    ];
+    static defaultProperties = {
+        className: "directory-name"
+    };
+}
+Object.assign(DirectoryNameDragEntryItem.prototype, _easydraganddrop.dropMixins);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/item/entry/drag/directoryName.js"],"sourcesContent":["\"use strict\";\n\nimport { dropMixins } from \"easy-drag-and-drop\";\nimport { pathUtilities } from \"necessary\";\n\nimport ToggleButton from \"../../../button/toggle\";\nimport DragEntryItem from \"../../../item/entry/drag\";\nimport DirectoryNameSVG from \"../../../svg/directoryName\";\nimport DirectoryNameDragEntryItemDiv from \"../../../div/item/entry/drag/directoryName\";\n\nimport { adjustSourceEntryPath, adjustTargetEntryPath } from \"../../../utilities/pathMap\";\nimport { FILE_NAME_DRAG_ENTRY_TYPE, FILE_NAME_MARKER_ENTRY_TYPE, DIRECTORY_NAME_DRAG_ENTRY_TYPE, DIRECTORY_NAME_MARKER_ENTRY_TYPE } from \"../../../entryTypes\";\n\nconst { concatenatePaths } = pathUtilities;\n\nexport default class DirectoryNameDragEntryItem extends DragEntryItem {\n\tdragOverCustomHandler = (event, element, dragElement) => {\n\t\tconst collapsed = this.isCollapsed();\n\n\t\tif (collapsed) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst path = this.getPath(),\n\t\t\t\t\texplorer = this.getExplorer(),\n\t\t\t\t\tdragEntryItem = dragElement,  ///\n\t\t\t\t\tmarkerEntryItem = this.retrieveMarkerEntryItem(),\n\t\t\t\t\tdragEntryItemName = dragEntryItem.getName();\n\n\t\tlet markerEntryItemPath = markerEntryItem.getPath(),\n\t\t\t\tmarkerEntryItemExplorer = markerEntryItem.getExplorer(),\n\t\t\t\tpreviousMarkerEntryItemPath = markerEntryItemPath, ///\n\t\t\t\tpreviousMarkerEntryItemExplorer = markerEntryItemExplorer; ///\n\n\t\tmarkerEntryItemPath = concatenatePaths(path, dragEntryItemName);\n\n\t\tmarkerEntryItemExplorer = explorer;  ///\n\n\t\tif ((markerEntryItemExplorer !== previousMarkerEntryItemExplorer) || (markerEntryItemPath !== previousMarkerEntryItemPath)) {\n\t\t\tconst dragEntryItemType = dragEntryItem.getType();\n\n\t\t\tpreviousMarkerEntryItemExplorer.removeMarker();\n\n\t\t\tmarkerEntryItemExplorer.addMarker(markerEntryItemPath, dragEntryItemType);\n\t\t}\n\t}\n\n\tdropCustomHandler = (event, element, dragElement, aborted, done) => {\n    const dragEntryItem = dragElement,  ///\n          markerEntryItem = this.retrieveMarkerEntryItem(),\n          markerEntryItemExplorer = markerEntryItem.getExplorer();\n\n    if (aborted) {\n      markerEntryItemExplorer.removeMarker();\n\n      done();\n\n      return;\n    }\n\n    markerEntryItemExplorer.dropDragEntryItem(event, element, dragEntryItem, done);\n  }\n\n\tdoubleClick(event, element) {\n\t\tlet collapsed = this.isCollapsed();\n\n\t\tcollapsed = !collapsed;\n\n\t\tcollapsed ?\n\t\t\tthis.collapse() :\n\t\t\t\tthis.expand();\n\t}\n\n\tsingleClick(event, element) {\n\t\tthis.expand();\n\t}\n\n\tisBefore(entryItem) {\n\t\tlet before;\n\n\t\tconst entryItemType = entryItem.getType();\n\n\t\tswitch (entryItemType) {\n\t\t\tcase FILE_NAME_DRAG_ENTRY_TYPE:\n\t\t\tcase FILE_NAME_MARKER_ENTRY_TYPE:\n\t\t\tcase DIRECTORY_NAME_MARKER_ENTRY_TYPE:\n\t\t\t\tbefore = true;\n\n\t\t\t\tbreak;\n\n\t\t\tcase DIRECTORY_NAME_DRAG_ENTRY_TYPE:\n\t\t\t\tconst name = this.getName(),\n\t\t\t\t\t\t\tentryItemName = entryItem.getName();\n\n\t\t\t\tbefore = (name.localeCompare(entryItemName) < 0);\n\n\t\t\t\tbreak;\n\t\t}\n\n\t\treturn before;\n\t}\n\n\tisTopmost() {\n\t\tconst { topmost } = this.properties;\n\n\t\treturn topmost;\n\t}\n\n\tisCollapsed() {\n\t\tconst entriesListCollapsed = this.isEntriesListCollapsed(),\n\t\t\t\t\tcollapsed = entriesListCollapsed;\t///\n\n\t\treturn collapsed;\n\t}\n\n\tgetReference() {\n\t\tconst explorer = this.getExplorer(),\n\t\t\t\t\treference = explorer.getReference();\n\n\t\treturn reference;\n\t}\n\n\tgetReferences() {\n\t\tconst explorer = this.getExplorer(),\n\t\t\t\t\treferences = explorer.getReferences();\n\n\t\treturn references;\n\t}\n\n\tretrievePathMaps(sourceEntryPath, targetEntryPath, pathMaps) {\n\t\tconst name = this.getName(),\n\t\t\t\t\tpathMap = this.getPathMap(sourceEntryPath, targetEntryPath),\n          nameSpanName = this.getNameSpanName();\n\n\t\tpathMaps.push(pathMap);\n\n\t\tsourceEntryPath = adjustSourceEntryPath(sourceEntryPath, name);\n\n\t\ttargetEntryPath = adjustTargetEntryPath(targetEntryPath, nameSpanName);\n\n\t\tthis.forEachDragEntryItem((dragEntryItem) => {\n\t\t\tdragEntryItem.retrievePathMaps(sourceEntryPath, targetEntryPath, pathMaps);\n\t\t});\n\t}\n\n\tremoveFromExplorer() {\n\t\tconst path = this.getPath(),\n\t\t\t\t\texplorer = this.getExplorer(),\n\t\t\t\t\tdirectoryPath = path;\t///\n\n\t\texplorer.removeDirectoryPath(directoryPath);\n\t}\n\n\tcollapse() {\n    this.collapseEntriesList();\n\t\tthis.collapseToggleButton();\n  }\n\n  expand() {\n    this.expandEntriesList();\n\t\tthis.expandToggleButton();\n  }\n\n\tdidMount() {\n\t\tconst { collapsed } = this.properties;\n\n\t\tcollapsed ?\n\t\t\tthis.collapse() :\n\t\t\t\tthis.expand();\n\n\t\tthis.enableDrop();\n\n\t\tthis.onCustomDrop(this.dropCustomHandler);\n\n\t\tthis.onCustomDragOver(this.dragOverCustomHandler);\n\n\t\tsuper.didMount();\n\t}\n\n\twillUnmount() {\n\t\tthis.disableDrop();\n\n\t\tthis.offCustomDrop(this.dropCustomHandler);\n\n\t\tthis.offCustomDragOver(this.dragOverCustomHandler);\n\n\t\tsuper.willUnmount();\n\t}\n\n  childElements() {\n\t\tconst { name } = this.properties,\n          { NameSpan, ToggleButton, DirectoryNameSVG } = this.constructor,\n          explorer = this.getExplorer(),\n          EntriesList = explorer.getEntriesList();\n\n\t\treturn ([\n\n\t\t\t<DirectoryNameDragEntryItemDiv name={name}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t explorer={explorer}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t NameSpan={NameSpan}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t ToggleButton={ToggleButton}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t DirectoryNameSVG={DirectoryNameSVG}\n\t\t\t/>,\n\t\t\t<EntriesList explorer={explorer} />\n\n\t\t]);\n\t}\n\n  static type = DIRECTORY_NAME_DRAG_ENTRY_TYPE;\n\n  static ToggleButton = ToggleButton;\n\n\tstatic DirectoryNameSVG = DirectoryNameSVG;\n\n\tstatic ignoredProperties = [\n\t\t\"topmost\"\n\t];\n\n\tstatic defaultProperties = {\n    className: \"directory-name\"\n  };\n}\n\nObject.assign(DirectoryNameDragEntryItem.prototype, dropMixins);\n"],"names":["DirectoryNameDragEntryItem","concatenatePaths","pathUtilities","DragEntryItem","dragOverCustomHandler","event","element","dragElement","collapsed","isCollapsed","path","getPath","explorer","getExplorer","dragEntryItem","markerEntryItem","retrieveMarkerEntryItem","dragEntryItemName","getName","markerEntryItemPath","markerEntryItemExplorer","previousMarkerEntryItemPath","previousMarkerEntryItemExplorer","dragEntryItemType","getType","removeMarker","addMarker","dropCustomHandler","aborted","done","dropDragEntryItem","doubleClick","collapse","expand","singleClick","isBefore","entryItem","before","entryItemType","FILE_NAME_DRAG_ENTRY_TYPE","FILE_NAME_MARKER_ENTRY_TYPE","DIRECTORY_NAME_MARKER_ENTRY_TYPE","DIRECTORY_NAME_DRAG_ENTRY_TYPE","name","entryItemName","localeCompare","isTopmost","topmost","properties","entriesListCollapsed","isEntriesListCollapsed","getReference","reference","getReferences","references","retrievePathMaps","sourceEntryPath","targetEntryPath","pathMaps","pathMap","getPathMap","nameSpanName","getNameSpanName","push","adjustSourceEntryPath","adjustTargetEntryPath","forEachDragEntryItem","removeFromExplorer","directoryPath","removeDirectoryPath","collapseEntriesList","collapseToggleButton","expandEntriesList","expandToggleButton","didMount","enableDrop","onCustomDrop","onCustomDragOver","willUnmount","disableDrop","offCustomDrop","offCustomDragOver","childElements","NameSpan","ToggleButton","DirectoryNameSVG","EntriesList","getEntriesList","DirectoryNameDragEntryItemDiv","type","ignoredProperties","defaultProperties","className","Object","assign","prototype","dropMixins"],"mappings":"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"}

package/lib/item/entry/drag/fileName.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return FileNameDragEntryItem;
+    }
+});
+const _fileName = /*#__PURE__*/ _interop_require_default(require("../../../svg/fileName"));
+const _drag = /*#__PURE__*/ _interop_require_default(require("../../../item/entry/drag"));
+const _fileName1 = /*#__PURE__*/ _interop_require_default(require("../../../div/item/entry/drag/fileName"));
+const _name = require("../../../utilities/name");
+const _entryTypes = require("../../../entryTypes");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class FileNameDragEntryItem extends _drag.default {
+    openFileNameDragEntryItem(event, element) {
+        const explorer = this.getExplorer(), fileNameDragEntryItem = this; ///
+        explorer.openFileNameDragEntryItem(event, element, fileNameDragEntryItem);
+    }
+    doubleClick(event, element) {
+        this.openFileNameDragEntryItem(event, element);
+    }
+    singleClick(event, element) {
+        this.openFileNameDragEntryItem(event, element);
+    }
+    isBefore(entryItem) {
+        let before;
+        const entryItemType = entryItem.getType();
+        switch(entryItemType){
+            case _entryTypes.FILE_NAME_DRAG_ENTRY_TYPE:
+            case _entryTypes.FILE_NAME_MARKER_ENTRY_TYPE:
+            case _entryTypes.DIRECTORY_NAME_MARKER_ENTRY_TYPE:
+                const name = this.getName(), entryItemName = entryItem.getName();
+                before = (0, _name.nameIsBeforeEntryItemName)(name, entryItemName);
+                break;
+            case _entryTypes.DIRECTORY_NAME_DRAG_ENTRY_TYPE:
+                before = false;
+                break;
+        }
+        return before;
+    }
+    getFileName() {
+        const name = this.getName(), fileName = name; ///
+        return fileName;
+    }
+    isCollapsed() {
+        const collapsed = null; ///
+        return collapsed;
+    }
+    retrievePathMaps(sourceEntryPath, targetEntryPath, pathMaps) {
+        const pathMap = this.getPathMap(sourceEntryPath, targetEntryPath);
+        pathMaps.push(pathMap);
+    }
+    removeFromExplorer() {
+        const path = this.getPath(), explorer = this.getExplorer(), filePath = path; ///
+        explorer.removeFilePath(filePath);
+    }
+    childElements() {
+        const { name } = this.properties, { NameSpan, FileNameSVG } = this.constructor, explorer = this.getExplorer();
+        return /*#__PURE__*/ React.createElement(_fileName1.default, {
+            name: name,
+            explorer: explorer,
+            NameSpan: NameSpan,
+            FileNameSVG: FileNameSVG
+        });
+    }
+    static type = _entryTypes.FILE_NAME_DRAG_ENTRY_TYPE;
+    static FileNameSVG = _fileName.default;
+    static defaultProperties = {
+        className: "file-name"
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/item/entry/drag.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _easywithstyle = /*#__PURE__*/ _interop_require_default(require("easy-with-style"));
+const _easydraganddrop = require("easy-drag-and-drop");
+const _name = /*#__PURE__*/ _interop_require_default(require("../../span/name"));
+const _entry = /*#__PURE__*/ _interop_require_default(require("../../item/entry"));
+const _constants = require("../../constants");
+const _entryTypes = require("../../entryTypes");
+const _pathMap = require("../../utilities/pathMap");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class DragEntryItem extends _entry.default {
+    nameSpanChangeCustomHandler = (event, element)=>{
+        const created = this.isCreated(), explorer = this.getExplorer(), nameSpanName = this.getNameSpanName();
+        explorer.enable();
+        if (nameSpanName === _constants.PERIOD || nameSpanName === _constants.EMPTY_STRING) {
+            this.cancel(created);
+            return;
+        }
+        const dragEntryItem = this; ///
+        if (created) {
+            explorer.createDragEntryItem(event, element, dragEntryItem, ()=>{
+            ///
+            });
+        } else {
+            explorer.renameDragEntryItem(event, element, dragEntryItem, ()=>{
+            ///
+            });
+        }
+    };
+    nameSpanCancelCustomHandler = (event, element)=>{
+        const created = this.isCreated(), explorer = this.getExplorer();
+        explorer.enable();
+        this.cancel(created);
+    };
+    startDragCustomHandler = (event, element)=>{
+        const path = this.getPath(), type = this.getType(), explorer = this.getExplorer(), dragEntryItemType = type, markerEntryItemPath = path; ///
+        explorer.addMarker(markerEntryItemPath, dragEntryItemType);
+    };
+    stopDragCustomHandler = (event, element, dropElement, aborted, done)=>{
+        if (dropElement !== null) {
+            done();
+            return;
+        }
+        const markerEntryItem = this.retrieveMarkerEntryItem(), markerEntryItemExplorer = markerEntryItem.getExplorer();
+        if (aborted) {
+            markerEntryItemExplorer.removeMarker();
+            done();
+            return;
+        }
+        const dragEntryItem = this; ///
+        markerEntryItemExplorer.dropDragEntryItem(event, element, dragEntryItem, done);
+    };
+    click(event, element) {
+        const explorer = this.getExplorer(), dragEntryItem = this, selected = explorer.selectOrDeselectDragEntryItem(event, element, dragEntryItem);
+        return selected;
+    }
+    isReadOnly() {
+        const { readOnly } = this.properties;
+        return readOnly;
+    }
+    getReferences() {
+        const explorer = this.getExplorer(), references = explorer.getReferences();
+        return references;
+    }
+    getPathMap(sourceEntryPath, targetEntryPath) {
+        const name = this.getName(), readOnly = this.isReadOnly(), collapsed = this.isCollapsed(), nameSpanName = this.getNameSpanName(), entryDirectory = this.isEntryDirectory();
+        sourceEntryPath = (0, _pathMap.adjustSourceEntryPath)(sourceEntryPath, name); ///
+        targetEntryPath = (0, _pathMap.adjustTargetEntryPath)(targetEntryPath, nameSpanName); ///
+        const pathMap = {
+            readOnly,
+            collapsed,
+            entryDirectory,
+            sourceEntryPath,
+            targetEntryPath
+        };
+        return pathMap;
+    }
+    getPathMaps(sourceEntryPath, targetEntryPath) {
+        let pathMaps = [];
+        this.retrievePathMaps(sourceEntryPath, targetEntryPath, pathMaps);
+        pathMaps.reverse();
+        return pathMaps;
+    }
+    isEntryDirectory() {
+        const directoryNameDragEntryItem = this.isDirectoryNameDragEntryItem(), entryDirectory = directoryNameDragEntryItem; ///
+        return entryDirectory;
+    }
+    retrieveMarkerEntryItem() {
+        const markerEntryItem = getMarkerEntryItem();
+        return markerEntryItem;
+    }
+    isDirectoryNameDragEntryItem() {
+        const type = this.getType(), typeDirectoryNameDragEntryItemType = type === _entryTypes.DIRECTORY_NAME_DRAG_ENTRY_TYPE, directoryNameDragEntryItem = typeDirectoryNameDragEntryItemType; ///
+        return directoryNameDragEntryItem;
+    }
+    setCreated(created) {
+        this.updateState({
+            created
+        });
+    }
+    isCreated() {
+        const { created } = this.getState();
+        return created;
+    }
+    isSelected() {
+        const selected = this.hasClass("selected"); ///
+        return selected;
+    }
+    deselect() {
+        this.removeClass("selected");
+    }
+    select() {
+        this.addClass("selected");
+    }
+    create() {
+        const created = true, explorer = this.getExplorer(), nameSpanName = _constants.EMPTY_STRING; ///
+        explorer.disable();
+        this.setCreated(created);
+        this.setNameSpanName(nameSpanName);
+        this.editNameSpan();
+    }
+    rename() {
+        const name = this.getName(), created = false, explorer = this.getExplorer(), nameSpanName = name; ///
+        explorer.disable();
+        this.setCreated(created);
+        this.setNameSpanName(nameSpanName);
+        this.editNameSpan();
+    }
+    reset() {
+        const name = this.getName(), nameSpanName = name; ///
+        this.setNameSpanName(nameSpanName);
+        this.resetNameSpan();
+    }
+    cancel(created) {
+        created ? this.removeFromExplorer() : this.reset();
+    }
+    didMount() {
+        const explorer = this.getExplorer(), disabled = explorer.isDisabled();
+        if (!disabled) {
+            this.enableDrag();
+        }
+        this.onCustomStopDrag(this.stopDragCustomHandler);
+        this.onCustomStartDrag(this.startDragCustomHandler);
+        this.onCustomNameSpanChange(this.nameSpanChangeCustomHandler);
+        this.onCustomNameSpanCancel(this.nameSpanCancelCustomHandler);
+    }
+    willUnmount() {
+        const explorer = this.getExplorer(), disabled = explorer.isDisabled();
+        if (!disabled) {
+            this.disableDrag();
+        }
+        this.offCustomStopDrag(this.stopDragCustomHandler);
+        this.offCustomStartDrag(this.startDragCustomHandler);
+        this.offCustomNameSpanChange(this.nameSpanChangeCustomHandler);
+        this.offCustomNameSpanCancel(this.nameSpanCancelCustomHandler);
+    }
+    parentContext() {
+        const context = this.getContext(), select = this.select.bind(this), deselect = this.deselect.bind(this);
+        return {
+            ...context,
+            select,
+            deselect
+        };
+    }
+    initialise() {
+        this.assignContext();
+    }
+    static NameSpan = _name.default;
+    static ignoredProperties = [
+        "readOnly"
+    ];
+    static defaultProperties = {
+        className: "drag"
+    };
+}
+Object.assign(_entry.default.prototype, _easydraganddrop.dragMixins);
+const _default = (0, _easywithstyle.default)(DragEntryItem)`
+
+  user-select: none;
+    
+  font-weight: normal;
+  
+  .selected {
+    font-weight: bold;
+  }
+
+  .dragging {
+    z-index: 1;
+    position: fixed;
+    pointer-events: none;
+  }
+  
+`;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/item/entry/drag.js"],"sourcesContent":["\"use strict\";\n\nimport withStyle from \"easy-with-style\";  ///\n\nimport { dragMixins } from \"easy-drag-and-drop\";\n\nimport NameSpan from \"../../span/name\";\nimport EntryItem from \"../../item/entry\";\n\nimport { PERIOD, EMPTY_STRING } from \"../../constants\";\nimport { DIRECTORY_NAME_DRAG_ENTRY_TYPE } from \"../../entryTypes\";\nimport { adjustSourceEntryPath, adjustTargetEntryPath } from \"../../utilities/pathMap\";\n\nclass DragEntryItem extends EntryItem {\n  nameSpanChangeCustomHandler = (event, element) => {\n    const created = this.isCreated(),\n          explorer = this.getExplorer(),\n          nameSpanName = this.getNameSpanName();\n\n    explorer.enable();\n\n    if ((nameSpanName === PERIOD) || (nameSpanName === EMPTY_STRING)) {\n      this.cancel(created);\n\n      return;\n    }\n\n    const dragEntryItem = this; ///\n\n    if (created) {\n      explorer.createDragEntryItem(event, element, dragEntryItem, () => {\n        ///\n      });\n    } else {\n      explorer.renameDragEntryItem(event, element, dragEntryItem, () => {\n        ///\n      });\n    }\n  }\n\n  nameSpanCancelCustomHandler = (event, element) => {\n    const created = this.isCreated(),\n          explorer = this.getExplorer();\n\n    explorer.enable();\n\n    this.cancel(created);\n  }\n\n  startDragCustomHandler = (event, element) => {\n    const path = this.getPath(),\n          type = this.getType(),\n          explorer = this.getExplorer(),\n          dragEntryItemType = type,  ///\n          markerEntryItemPath = path;  ///\n\n    explorer.addMarker(markerEntryItemPath, dragEntryItemType);\n  }\n\n  stopDragCustomHandler = (event, element, dropElement, aborted, done) => {\n    if (dropElement !== null) {\n      done();\n\n      return;\n    }\n\n    const markerEntryItem = this.retrieveMarkerEntryItem(),\n          markerEntryItemExplorer = markerEntryItem.getExplorer();\n\n    if (aborted) {\n      markerEntryItemExplorer.removeMarker();\n\n      done();\n\n      return;\n    }\n\n    const dragEntryItem = this;  ///\n\n    markerEntryItemExplorer.dropDragEntryItem(event, element, dragEntryItem, done);\n  }\n\n  click(event, element) {\n    const explorer = this.getExplorer(),\n          dragEntryItem = this, ///\n          selected = explorer.selectOrDeselectDragEntryItem(event, element, dragEntryItem);\n\n    return selected;\n  }\n\n  isReadOnly() {\n    const { readOnly } = this.properties;\n\n    return readOnly;\n  }\n\n  getReferences() {\n    const explorer = this.getExplorer(),\n          references = explorer.getReferences();\n\n    return references;\n  }\n\n  getPathMap(sourceEntryPath, targetEntryPath) {\n    const name = this.getName(),\n          readOnly = this.isReadOnly(),\n          collapsed = this.isCollapsed(),\n          nameSpanName = this.getNameSpanName(),\n          entryDirectory = this.isEntryDirectory();\n\n    sourceEntryPath = adjustSourceEntryPath(sourceEntryPath, name);\t///\n\n    targetEntryPath = adjustTargetEntryPath(targetEntryPath, nameSpanName);\t///\n\n    const pathMap = {\n      readOnly,\n      collapsed,\n      entryDirectory,\n      sourceEntryPath,\n      targetEntryPath\n    };\n\n    return pathMap;\n  }\n\n  getPathMaps(sourceEntryPath, targetEntryPath) {\n    let pathMaps = [];\n\n    this.retrievePathMaps(sourceEntryPath, targetEntryPath, pathMaps);\n\n    pathMaps.reverse();\n\n    return pathMaps;\n  }\n\n  isEntryDirectory() {\n    const directoryNameDragEntryItem = this.isDirectoryNameDragEntryItem(),\n          entryDirectory = directoryNameDragEntryItem;  ///\n\n    return entryDirectory;\n  }\n\n  retrieveMarkerEntryItem() {\n    const markerEntryItem = getMarkerEntryItem();\n\n    return markerEntryItem;\n  }\n\n  isDirectoryNameDragEntryItem() {\n    const type = this.getType(),\n          typeDirectoryNameDragEntryItemType = (type === DIRECTORY_NAME_DRAG_ENTRY_TYPE),\n          directoryNameDragEntryItem = typeDirectoryNameDragEntryItemType;  ///\n\n    return directoryNameDragEntryItem;\n  }\n\n  setCreated(created) {\n    this.updateState({\n      created\n    });\n  }\n\n  isCreated() {\n    const { created } = this.getState();\n\n    return created;\n  }\n\n  isSelected() {\n    const selected = this.hasClass(\"selected\"); ///\n\n    return selected;\n  }\n\n  deselect() {\n    this.removeClass(\"selected\");\n  }\n\n  select() {\n    this.addClass(\"selected\");\n  }\n\n  create() {\n    const created = true,\n          explorer = this.getExplorer(),\n          nameSpanName = EMPTY_STRING; ///\n\n    explorer.disable();\n\n    this.setCreated(created);\n\n    this.setNameSpanName(nameSpanName);\n\n    this.editNameSpan();\n  }\n\n  rename() {\n    const name = this.getName(),\n          created = false,\n          explorer = this.getExplorer(),\n          nameSpanName = name; ///\n\n    explorer.disable();\n\n    this.setCreated(created);\n\n    this.setNameSpanName(nameSpanName);\n\n    this.editNameSpan();\n  }\n\n  reset() {\n    const name = this.getName(),\n          nameSpanName = name; ///\n\n    this.setNameSpanName(nameSpanName);\n\n    this.resetNameSpan();\n  }\n\n  cancel(created) {\n    created ?\n      this.removeFromExplorer() :\n        this.reset();\n  }\n\n  didMount() {\n    const explorer = this.getExplorer(),\n          disabled = explorer.isDisabled();\n\n    if (!disabled) {\n      this.enableDrag();\n    }\n\n    this.onCustomStopDrag(this.stopDragCustomHandler);\n\n    this.onCustomStartDrag(this.startDragCustomHandler);\n\n    this.onCustomNameSpanChange(this.nameSpanChangeCustomHandler);\n\n    this.onCustomNameSpanCancel(this.nameSpanCancelCustomHandler);\n\t}\n\n\twillUnmount() {\n    const explorer = this.getExplorer(),\n          disabled = explorer.isDisabled();\n\n    if (!disabled) {\n      this.disableDrag();\n    }\n\n    this.offCustomStopDrag(this.stopDragCustomHandler);\n\n    this.offCustomStartDrag(this.startDragCustomHandler);\n\n    this.offCustomNameSpanChange(this.nameSpanChangeCustomHandler);\n\n    this.offCustomNameSpanCancel(this.nameSpanCancelCustomHandler);\n\t}\n\n  parentContext() {\n    const context = this.getContext(),\n          select = this.select.bind(this),\n          deselect = this.deselect.bind(this);\n\n    return ({\n      ...context,\n      select,\n      deselect\n    });\n  }\n\n  initialise() {\n\t\tthis.assignContext();\n\t}\n\n  static NameSpan = NameSpan;\n\n  static ignoredProperties = [\n    \"readOnly\"\n  ];\n\n  static defaultProperties = {\n\t\tclassName: \"drag\"\n\t};\n}\n\nObject.assign(EntryItem.prototype, dragMixins);\n\nexport default withStyle(DragEntryItem)`\n\n  user-select: none;\n    \n  font-weight: normal;\n  \n  .selected {\n    font-weight: bold;\n  }\n\n  .dragging {\n    z-index: 1;\n    position: fixed;\n    pointer-events: none;\n  }\n  \n`;\n"],"names":["DragEntryItem","EntryItem","nameSpanChangeCustomHandler","event","element","created","isCreated","explorer","getExplorer","nameSpanName","getNameSpanName","enable","PERIOD","EMPTY_STRING","cancel","dragEntryItem","createDragEntryItem","renameDragEntryItem","nameSpanCancelCustomHandler","startDragCustomHandler","path","getPath","type","getType","dragEntryItemType","markerEntryItemPath","addMarker","stopDragCustomHandler","dropElement","aborted","done","markerEntryItem","retrieveMarkerEntryItem","markerEntryItemExplorer","removeMarker","dropDragEntryItem","click","selected","selectOrDeselectDragEntryItem","isReadOnly","readOnly","properties","getReferences","references","getPathMap","sourceEntryPath","targetEntryPath","name","getName","collapsed","isCollapsed","entryDirectory","isEntryDirectory","adjustSourceEntryPath","adjustTargetEntryPath","pathMap","getPathMaps","pathMaps","retrievePathMaps","reverse","directoryNameDragEntryItem","isDirectoryNameDragEntryItem","getMarkerEntryItem","typeDirectoryNameDragEntryItemType","DIRECTORY_NAME_DRAG_ENTRY_TYPE","setCreated","updateState","getState","isSelected","hasClass","deselect","removeClass","select","addClass","create","disable","setNameSpanName","editNameSpan","rename","reset","resetNameSpan","removeFromExplorer","didMount","disabled","isDisabled","enableDrag","onCustomStopDrag","onCustomStartDrag","onCustomNameSpanChange","onCustomNameSpanCancel","willUnmount","disableDrag","offCustomStopDrag","offCustomStartDrag","offCustomNameSpanChange","offCustomNameSpanCancel","parentContext","context","getContext","bind","initialise","assignContext","NameSpan","ignoredProperties","defaultProperties","className","Object","assign","prototype","dragMixins","withStyle"],"mappings":"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"}

package/lib/item/entry/marker/directoryName.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return DirectoryNameMarkerEntryItem;
+    }
+});
+const _marker = /*#__PURE__*/ _interop_require_default(require("../../../item/entry/marker"));
+const _entryTypes = require("../../../entryTypes");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class DirectoryNameMarkerEntryItem extends _marker.default {
+    isBefore(dragEntryItem) {
+        let before;
+        const dragEntryItemType = dragEntryItem.getType();
+        switch(dragEntryItemType){
+            case _entryTypes.FILE_NAME_DRAG_ENTRY_TYPE:
+                before = true;
+                break;
+            case _entryTypes.DIRECTORY_NAME_DRAG_ENTRY_TYPE:
+                const name = this.getName(), dragEntryItemName = dragEntryItem.getName();
+                before = name.localeCompare(dragEntryItemName) < 0;
+                break;
+        }
+        return before;
+    }
+    static type = _entryTypes.DIRECTORY_NAME_MARKER_ENTRY_TYPE;
+    static defaultProperties = {
+        className: "directory-name"
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/item/entry/marker/fileName.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return FileNameMarkerEntryItem;
+    }
+});
+const _marker = /*#__PURE__*/ _interop_require_default(require("../../../item/entry/marker"));
+const _name = require("../../../utilities/name");
+const _entryTypes = require("../../../entryTypes");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class FileNameMarkerEntryItem extends _marker.default {
+    isBefore(dragEntryItem) {
+        let before;
+        const dragEntryItemType = dragEntryItem.getType();
+        switch(dragEntryItemType){
+            case _entryTypes.FILE_NAME_DRAG_ENTRY_TYPE:
+                const name = this.getName(), dragEntryItemName = dragEntryItem.getName();
+                before = (0, _name.nameIsBeforeEntryItemName)(name, dragEntryItemName);
+                break;
+            case _entryTypes.DIRECTORY_NAME_DRAG_ENTRY_TYPE:
+                before = false;
+                break;
+        }
+        return before;
+    }
+    static type = _entryTypes.FILE_NAME_MARKER_ENTRY_TYPE;
+    static defaultProperties = {
+        className: "file-name"
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/item/entry/marker.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return MarkerEntryItem;
+    }
+});
+const _entry = /*#__PURE__*/ _interop_require_default(require("../../item/entry"));
+const _marker = /*#__PURE__*/ _interop_require_default(require("../../svg/marker"));
+const _marker1 = /*#__PURE__*/ _interop_require_default(require("../../div/item/entry/marker"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class MarkerEntryItem extends _entry.default {
+    childElements() {
+        const { MarkerSVG } = this.constructor;
+        return /*#__PURE__*/ React.createElement(_marker1.default, {
+            MarkerSVG: MarkerSVG
+        });
+    }
+    static MarkerSVG = _marker.default;
+    static defaultProperties = {
+        className: "marker"
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9pdGVtL2VudHJ5L21hcmtlci5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuaW1wb3J0IEVudHJ5SXRlbSBmcm9tIFwiLi4vLi4vaXRlbS9lbnRyeVwiO1xuaW1wb3J0IE1hcmtlclNWRyBmcm9tIFwiLi4vLi4vc3ZnL21hcmtlclwiO1xuaW1wb3J0IE1hcmtlckVudHJ5SXRlbURpdiBmcm9tIFwiLi4vLi4vZGl2L2l0ZW0vZW50cnkvbWFya2VyXCI7XG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIE1hcmtlckVudHJ5SXRlbSBleHRlbmRzIEVudHJ5SXRlbSB7XG4gIGNoaWxkRWxlbWVudHMoKSB7XG4gICAgY29uc3QgeyBNYXJrZXJTVkcgfSA9IHRoaXMuY29uc3RydWN0b3I7XG5cbiAgICByZXR1cm4gKFxuXG4gICAgICA8TWFya2VyRW50cnlJdGVtRGl2IE1hcmtlclNWRz17TWFya2VyU1ZHfSAvPlxuXG4gICAgKTtcbiAgfVxuXG4gIHN0YXRpYyBNYXJrZXJTVkcgPSBNYXJrZXJTVkc7XG5cbiAgc3RhdGljIGRlZmF1bHRQcm9wZXJ0aWVzID0ge1xuICAgIGNsYXNzTmFtZTogXCJtYXJrZXJcIlxuICB9O1xufVxuIl0sIm5hbWVzIjpbIk1hcmtlckVudHJ5SXRlbSIsIkVudHJ5SXRlbSIsImNoaWxkRWxlbWVudHMiLCJNYXJrZXJTVkciLCJNYXJrZXJFbnRyeUl0ZW1EaXYiLCJkZWZhdWx0UHJvcGVydGllcyIsImNsYXNzTmFtZSJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7K0JBTUE7OztlQUFxQkE7Ozs4REFKQzsrREFDQTtnRUFDUzs7Ozs7O0FBRWhCLE1BQU1BLHdCQUF3QkMsY0FBUztJQUNwREMsZ0JBQWdCO1FBQ2QsTUFBTSxFQUFFQyxTQUFTLEVBQUUsR0FBRyxJQUFJLENBQUMsV0FBVztRQUV0QyxxQkFFRSxvQkFBQ0MsZ0JBQWtCO1lBQUNELFdBQVdBOztJQUduQztJQUVBLE9BQU9BLFlBQVlBLGVBQVMsQ0FBQztJQUU3QixPQUFPRSxvQkFBb0I7UUFDekJDLFdBQVc7SUFDYixFQUFFO0FBQ0oifQ==