@jahia/data-helper 1.0.5 → 1.0.7

package/esm/legacy/Picker.js

@@ -1,5 +1,4 @@
 function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
-
 import _includes from "lodash/includes";
 import _startsWith from "lodash/startsWith";
 import _split from "lodash/split";
@@ -16,53 +15,27 @@ import _union from "lodash/union";
 import _eq from "lodash/eq";
 import _clone from "lodash/clone";
 import _filter from "lodash/filter";
-
+var _templateObject;
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
 function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-
 function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function _templateObject() {
-  var data = _taggedTemplateLiteral(["\n            query PickerQuery($rootPaths:[String!]!, $selectable:[String]!, $openable:[String]!, $openPaths:[String!]!, $types:[String]!) {\n                jcr {\n                    rootNodes:nodesByPath(paths: $rootPaths) {\n                        name\n                        children(typesFilter:{types:$types}, limit:1) {\n                            pageInfo {\n                                nodesCount\n                            }\n                        }\n                        selectable : isNodeType(type: {types:$selectable})\n                        openable : isNodeType(type: {types:$openable})\n                        ... NodeCacheRequiredFields\n                        ... node\n                    },\n                    openNodes:nodesByPath(paths: $openPaths) {\n                        ... NodeCacheRequiredFields\n                        children(typesFilter:{types:$types}) {\n                            nodes {\n                                name\n                                children(typesFilter:{types:$types}, limit:1) {\n                                    pageInfo {\n                                        nodesCount\n                                    }\n                                }\n                                selectable : isNodeType(type: {types:$selectable})\n                                openable : isNodeType(type: {types:$openable})\n                                ... NodeCacheRequiredFields\n                                ... node\n                            }\n                        }\n                    }\n                }\n            }\n        ", ""]);
-
-  _templateObject = function _templateObject() {
-    return data;
-  };
-
-  return data;
-}
-
 function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
-
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 // TODO BACKLOG-12393 - refactor Legacy Picker into hook without lodash
 import React from 'react';
 import { Query } from 'react-apollo';
@@ -72,32 +45,28 @@ import { displayName, nodeCacheRequiredFields, replaceFragmentsInDocument } from
 import { PickerItemsFragment } from './Picker.gql-fragments';
 export var Picker = /*#__PURE__*/function (_React$Component) {
   _inherits(Picker, _React$Component);
-
+  var _super = _createSuper(Picker);
   function Picker(props) {
     var _this;
-
     _classCallCheck(this, Picker);
-
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(Picker).call(this, props));
+    _this = _super.call(this, props);
     var fragments = props.fragments,
-        rootPaths = props.rootPaths,
-        onOpenItem = props.onOpenItem,
-        onSelectItem = props.onSelectItem,
-        openPaths = props.openPaths,
-        selectedPaths = props.selectedPaths,
-        defaultSelectedPaths = props.defaultSelectedPaths,
-        onSelectionChange = props.onSelectionChange,
-        defaultOpenPaths = props.defaultOpenPaths;
-    _this.query = gql(_templateObject(), nodeCacheRequiredFields.gql);
+      rootPaths = props.rootPaths,
+      onOpenItem = props.onOpenItem,
+      onSelectItem = props.onSelectItem,
+      openPaths = props.openPaths,
+      selectedPaths = props.selectedPaths,
+      defaultSelectedPaths = props.defaultSelectedPaths,
+      onSelectionChange = props.onSelectionChange,
+      defaultOpenPaths = props.defaultOpenPaths;
+    _this.query = gql(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n            query PickerQuery($rootPaths:[String!]!, $selectable:[String]!, $openable:[String]!, $openPaths:[String!]!, $types:[String]!) {\n                jcr {\n                    rootNodes:nodesByPath(paths: $rootPaths) {\n                        name\n                        children(typesFilter:{types:$types}, limit:1) {\n                            pageInfo {\n                                nodesCount\n                            }\n                        }\n                        selectable : isNodeType(type: {types:$selectable})\n                        openable : isNodeType(type: {types:$openable})\n                        ... NodeCacheRequiredFields\n                        ... node\n                    },\n                    openNodes:nodesByPath(paths: $openPaths) {\n                        ... NodeCacheRequiredFields\n                        children(typesFilter:{types:$types}) {\n                            nodes {\n                                name\n                                children(typesFilter:{types:$types}, limit:1) {\n                                    pageInfo {\n                                        nodesCount\n                                    }\n                                }\n                                selectable : isNodeType(type: {types:$selectable})\n                                openable : isNodeType(type: {types:$openable})\n                                ... NodeCacheRequiredFields\n                                ... node\n                            }\n                        }\n                    }\n                }\n            }\n        ", ""])), nodeCacheRequiredFields.gql);
     _this.query = replaceFragmentsInDocument(_this.query, fragments);
     var state = {};
     _this.eventsHandlers = {};
-
     if (openPaths === null) {
       // Uncontrolled mode
       state.isOpenControlled = false;
       state.openPaths = [];
-
       _this.eventsHandlers.onOpenItem = function (path, open) {
         _this.setState(function (prevState) {
           return {
@@ -107,27 +76,23 @@ export var Picker = /*#__PURE__*/function (_React$Component) {
           };
         });
       };
-
       if (defaultOpenPaths) {
         state.openPaths = _this.addPathToOpenPath(defaultOpenPaths, rootPaths, state.openPaths);
       }
     } else {
       state.isOpenControlled = true;
-
       if (onOpenItem) {
         _this.eventsHandlers.onOpenItem = onOpenItem;
       }
     }
-
     if (selectedPaths === null) {
       // Uncontrolled mode
       state.isSelectControlled = false;
-      state.selectedPaths = defaultSelectedPaths ? _clone(defaultSelectedPaths) : []; // Open selected path if open is uncontrolled
-
+      state.selectedPaths = defaultSelectedPaths ? _clone(defaultSelectedPaths) : [];
+      // Open selected path if open is uncontrolled
       if (defaultSelectedPaths && !state.isOpenControlled) {
         state.openPaths = _this.addPathToOpenPath(defaultSelectedPaths, rootPaths, state.openPaths);
       }
-
       _this.eventsHandlers.onSelectItem = function (path, selected, multiple) {
         _this.setState(function (prevState) {
           var newSelectedPaths = selected ? [].concat(_toConsumableArray(multiple ? prevState.selectedPaths : []), [path]) : _filter(prevState.selectedPaths, function (thispath) {
@@ -141,26 +106,24 @@ export var Picker = /*#__PURE__*/function (_React$Component) {
       };
     } else if (onSelectItem) {
       state.isSelectControlled = true;
-
       if (onSelectItem) {
         _this.eventsHandlers.onSelectItem = onSelectItem;
       }
     }
+    _this.state = state;
 
-    _this.state = state; // Binding
-
+    // Binding
     _this.openPaths = _this.openPaths.bind(_assertThisInitialized(_this));
     return _this;
   }
-
   _createClass(Picker, [{
     key: "getVariables",
     value: function getVariables(selectedPaths, openPaths) {
       var _this$props = this.props,
-          rootPaths = _this$props.rootPaths,
-          openableTypes = _this$props.openableTypes,
-          selectableTypes = _this$props.selectableTypes,
-          queryVariables = _this$props.queryVariables;
+        rootPaths = _this$props.rootPaths,
+        openableTypes = _this$props.openableTypes,
+        selectableTypes = _this$props.selectableTypes,
+        queryVariables = _this$props.queryVariables;
       var vars = {
         rootPaths: rootPaths,
         types: _union(openableTypes, selectableTypes),
@@ -168,29 +131,23 @@ export var Picker = /*#__PURE__*/function (_React$Component) {
         openable: openableTypes,
         openPaths: openPaths
       };
-
       if (queryVariables) {
         _assign(vars, queryVariables);
       }
-
       return vars;
     }
   }, {
     key: "getPickerEntries",
     value: function getPickerEntries(data, selectedPaths, openPaths) {
       var _this2 = this;
-
       var pickerEntries = [];
       var nodesById = {};
       var jcr = data.jcr;
-
       var addNode = function addNode(node, depth, index) {
         var selected = false;
-
         if (node.selectable) {
           selected = _indexOf(selectedPaths, node.path) !== -1;
         }
-
         var pickerNode = {
           name: node.name,
           path: node.path,
@@ -208,7 +165,6 @@ export var Picker = /*#__PURE__*/function (_React$Component) {
         nodesById[node.uuid] = pickerNode;
         return pickerNode;
       };
-
       if (jcr) {
         if (jcr.rootNodes) {
           _forEach(jcr.rootNodes, function (rootNode) {
@@ -216,29 +172,25 @@ export var Picker = /*#__PURE__*/function (_React$Component) {
             root.hidden = _this2.props.hideRoot;
           });
         }
-
         if (jcr.openNodes) {
           _sortBy(jcr.openNodes, ['path']).forEach(function (node) {
             var parent = nodesById[node.uuid];
-
             if (parent) {
               var parentIndex = _indexOf(pickerEntries, parent);
-
               _forEachRight(node.children.nodes, function (child) {
                 addNode(child, parent.depth + 1, parentIndex + 1);
               });
             }
           });
         }
-      } // Nodes loaded, fill selection list
-
+      }
 
+      // Nodes loaded, fill selection list
       var selectedNodes = _filter(pickerEntries, function (node) {
         return node.selected;
       }).map(function (node) {
         return node.node;
       });
-
       selectedPaths = _map(selectedNodes, 'path');
       pickerEntries = _filter(pickerEntries, function (pickerNode) {
         return !pickerNode.hidden;
@@ -250,44 +202,35 @@ export var Picker = /*#__PURE__*/function (_React$Component) {
     value: function addPathToOpenPath(pathsToOpen, rootPaths, openPaths) {
       _each(pathsToOpen, function (path) {
         var rootFound = false;
-
         if (!path.endsWith('/')) {
           path += '/';
         }
-
         _tail(_split(path, '/')).reduce(function (acc, it) {
           if (!rootFound) {
             _forEach(rootPaths, function (rootPath) {
               rootFound = rootFound || _startsWith(acc, rootPath) && rootPath;
             });
           }
-
           if (rootFound && !_includes(openPaths, acc)) {
             openPaths.push(acc);
-
             if (!_includes(openPaths, rootFound)) {
               openPaths.push(rootFound);
             }
           }
-
           return acc + '/' + it;
         }, '');
       });
-
       return openPaths;
     }
   }, {
     key: "openPaths",
     value: function openPaths(paths) {
       var _this3 = this;
-
       if (!(paths instanceof Array)) {
         paths = [paths];
       }
-
       this.setState(function (prevState) {
         var openPaths = _this3.addPathToOpenPath(paths, _this3.props.rootPaths, prevState.openPaths);
-
         return {
           openPaths: openPaths
         };
@@ -297,22 +240,20 @@ export var Picker = /*#__PURE__*/function (_React$Component) {
     key: "render",
     value: function render() {
       var _this4 = this;
-
       var selectedPaths = this.state.selectedPaths ? this.state.selectedPaths : this.props.selectedPaths;
       var openPaths = this.state.openPaths ? this.state.openPaths : this.props.openPaths;
       var setRefetch = this.props.setRefetch;
       openPaths = _clone(openPaths);
       var vars = this.getVariables(selectedPaths, openPaths);
-      return React.createElement(Query, {
+      return /*#__PURE__*/React.createElement(Query, {
         query: this.query,
         variables: vars,
         fetchPolicy: "cache-first"
       }, function (_ref) {
         var error = _ref.error,
-            loading = _ref.loading,
-            data = _ref.data,
-            refetch = _ref.refetch;
-
+          loading = _ref.loading,
+          data = _ref.data,
+          refetch = _ref.refetch;
         if (setRefetch) {
           setRefetch({
             query: _this4.query,
@@ -320,13 +261,10 @@ export var Picker = /*#__PURE__*/function (_React$Component) {
             refetch: refetch
           });
         }
-
         var renderProp = _this4.props.children;
-
         if (_this4.props.onLoading) {
           _this4.props.onLoading(loading);
         }
-
         if (loading) {
           if (_this4.previousEntries) {
             return renderProp(_objectSpread({
@@ -334,13 +272,11 @@ export var Picker = /*#__PURE__*/function (_React$Component) {
               loading: loading
             }, _this4.eventsHandlers));
           }
-
           return renderProp(_objectSpread({
             pickerEntries: [],
             loading: loading
           }, _this4.eventsHandlers));
         }
-
         if (error) {
           return renderProp(_objectSpread({
             pickerEntries: [],
@@ -348,9 +284,7 @@ export var Picker = /*#__PURE__*/function (_React$Component) {
             loading: loading
           }, _this4.eventsHandlers));
         }
-
         var pickerEntries = _this4.getPickerEntries(data, selectedPaths, openPaths);
-
         _this4.previousEntries = pickerEntries;
         return renderProp(_objectSpread({
           pickerEntries: pickerEntries,
@@ -364,25 +298,19 @@ export var Picker = /*#__PURE__*/function (_React$Component) {
       if (prevState.isOpenControlled !== (nextProps.openPaths !== null) || prevState.isSelectControlled !== (nextProps.selectedPaths !== null)) {
         console.warn('Cannot change between controlled/uncontrolled modes');
       }
-
       var newState = {};
-
       if (prevState.isOpenControlled && !_eq(nextProps.openPaths, prevState.openPaths)) {
         newState.openPaths = nextProps.openPaths;
       }
-
       if (prevState.isSelectControlled && !_eq(nextProps.selectedPaths, prevState.selectedPaths)) {
         newState.selectedPaths = nextProps.selectedPaths;
       }
-
       if (newState.openPaths || newState.selectedPaths) {
         return newState;
       }
-
       return null;
     }
   }]);
-
   return Picker;
 }(React.Component);
 Picker.defaultProps = {
@@ -405,47 +333,38 @@ Picker.propTypes = {
    * List of root paths for the picker
    */
   rootPaths: PropTypes.arrayOf(PropTypes.string).isRequired,
-
   /**
    * List of folder paths that are open by default (uncontrolled mode)
    */
   defaultOpenPaths: PropTypes.arrayOf(PropTypes.string),
-
   /**
    * List of node types that can be "opened" (folders)
    */
   openableTypes: PropTypes.arrayOf(PropTypes.string).isRequired,
-
   /**
    * List of open folders in controlled mode
    */
   openPaths: PropTypes.arrayOf(PropTypes.string),
-
   /**
    * List of node types that can be "selected" (items)
    */
   selectableTypes: PropTypes.arrayOf(PropTypes.string).isRequired,
-
   /**
    * Preselected items path (uncontrolled mode)
    */
   defaultSelectedPaths: PropTypes.arrayOf(PropTypes.string),
-
   /**
    * List of selected path in controlled mode
    */
   selectedPaths: PropTypes.arrayOf(PropTypes.string),
-
   /**
    * Callback when the selection has changed
    */
   onSelectionChange: PropTypes.func,
-
   /**
    * Optional function which receives refetch function of the Query component when the component is strapped
    */
   setRefetch: PropTypes.func,
-
   /**
    * Optional set of fragments to add to the graphQL query. Can be a string that identify a predefinedFragment or a fragment definition
    */
@@ -454,7 +373,6 @@ Picker.propTypes = {
     variables: PropTypes.object,
     gql: PropTypes.object.isRequired
   })])),
-
   /**
    * Optional set of variable to pass to the graphQL query, in order to fulfill fragments needs
    */