datastake-daf 0.6.535 → 0.6.536

package/dist/hooks/index.js

@@ -7,10 +7,17 @@ var g2 = require('@antv/g2');
 var g2plot = require('@antv/g2plot');
 require('country-city-location');
 var L = require('leaflet');
+var lodash = require('lodash');
+var PropTypes = require('prop-types');
+var reactIs = require('react-is');
+require('react-dom');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 var L__default = /*#__PURE__*/_interopDefaultLegacy(L);
+var PropTypes__default = /*#__PURE__*/_interopDefaultLegacy(PropTypes);
+var reactIs__default = /*#__PURE__*/_interopDefaultLegacy(reactIs);
 
 const defaultFilterKeys = ["search", "sortDir", "sortBy", "timeframe", "activeTab"];
 function hasJsonStructure(str) {
@@ -1272,6 +1279,305 @@ const useMapOnExpandableWidget = ({
   };
 };
 
+var global$1 = (typeof global !== "undefined" ? global :
+  typeof self !== "undefined" ? self :
+  typeof window !== "undefined" ? window : {});
+
+// shim for using process in browser
+// based off https://github.com/defunctzombie/node-process/blob/master/browser.js
+
+function defaultSetTimout() {
+    throw new Error('setTimeout has not been defined');
+}
+function defaultClearTimeout () {
+    throw new Error('clearTimeout has not been defined');
+}
+var cachedSetTimeout = defaultSetTimout;
+var cachedClearTimeout = defaultClearTimeout;
+if (typeof global$1.setTimeout === 'function') {
+    cachedSetTimeout = setTimeout;
+}
+if (typeof global$1.clearTimeout === 'function') {
+    cachedClearTimeout = clearTimeout;
+}
+
+function runTimeout(fun) {
+    if (cachedSetTimeout === setTimeout) {
+        //normal enviroments in sane situations
+        return setTimeout(fun, 0);
+    }
+    // if setTimeout wasn't available but was latter defined
+    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+        cachedSetTimeout = setTimeout;
+        return setTimeout(fun, 0);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedSetTimeout(fun, 0);
+    } catch(e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+            return cachedSetTimeout.call(null, fun, 0);
+        } catch(e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+            return cachedSetTimeout.call(this, fun, 0);
+        }
+    }
+
+
+}
+function runClearTimeout(marker) {
+    if (cachedClearTimeout === clearTimeout) {
+        //normal enviroments in sane situations
+        return clearTimeout(marker);
+    }
+    // if clearTimeout wasn't available but was latter defined
+    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+        cachedClearTimeout = clearTimeout;
+        return clearTimeout(marker);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedClearTimeout(marker);
+    } catch (e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+            return cachedClearTimeout.call(null, marker);
+        } catch (e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+            return cachedClearTimeout.call(this, marker);
+        }
+    }
+
+
+
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+
+function cleanUpNextTick() {
+    if (!draining || !currentQueue) {
+        return;
+    }
+    draining = false;
+    if (currentQueue.length) {
+        queue = currentQueue.concat(queue);
+    } else {
+        queueIndex = -1;
+    }
+    if (queue.length) {
+        drainQueue();
+    }
+}
+
+function drainQueue() {
+    if (draining) {
+        return;
+    }
+    var timeout = runTimeout(cleanUpNextTick);
+    draining = true;
+
+    var len = queue.length;
+    while(len) {
+        currentQueue = queue;
+        queue = [];
+        while (++queueIndex < len) {
+            if (currentQueue) {
+                currentQueue[queueIndex].run();
+            }
+        }
+        queueIndex = -1;
+        len = queue.length;
+    }
+    currentQueue = null;
+    draining = false;
+    runClearTimeout(timeout);
+}
+function nextTick(fun) {
+    var args = new Array(arguments.length - 1);
+    if (arguments.length > 1) {
+        for (var i = 1; i < arguments.length; i++) {
+            args[i - 1] = arguments[i];
+        }
+    }
+    queue.push(new Item(fun, args));
+    if (queue.length === 1 && !draining) {
+        runTimeout(drainQueue);
+    }
+}
+// v8 likes predictible objects
+function Item(fun, array) {
+    this.fun = fun;
+    this.array = array;
+}
+Item.prototype.run = function () {
+    this.fun.apply(null, this.array);
+};
+var title = 'browser';
+var platform = 'browser';
+var browser = true;
+var env = {};
+var argv = [];
+var version = ''; // empty string to avoid regexp issues
+var versions = {};
+var release = {};
+var config = {};
+
+function noop() {}
+
+var on = noop;
+var addListener = noop;
+var once = noop;
+var off = noop;
+var removeListener = noop;
+var removeAllListeners = noop;
+var emit = noop;
+
+function binding(name) {
+    throw new Error('process.binding is not supported');
+}
+
+function cwd () { return '/' }
+function chdir (dir) {
+    throw new Error('process.chdir is not supported');
+}function umask() { return 0; }
+
+// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js
+var performance = global$1.performance || {};
+var performanceNow =
+  performance.now        ||
+  performance.mozNow     ||
+  performance.msNow      ||
+  performance.oNow       ||
+  performance.webkitNow  ||
+  function(){ return (new Date()).getTime() };
+
+// generate timestamp or delta
+// see http://nodejs.org/api/process.html#process_process_hrtime
+function hrtime(previousTimestamp){
+  var clocktime = performanceNow.call(performance)*1e-3;
+  var seconds = Math.floor(clocktime);
+  var nanoseconds = Math.floor((clocktime%1)*1e9);
+  if (previousTimestamp) {
+    seconds = seconds - previousTimestamp[0];
+    nanoseconds = nanoseconds - previousTimestamp[1];
+    if (nanoseconds<0) {
+      seconds--;
+      nanoseconds += 1e9;
+    }
+  }
+  return [seconds,nanoseconds]
+}
+
+var startTime = new Date();
+function uptime() {
+  var currentTime = new Date();
+  var dif = currentTime - startTime;
+  return dif / 1000;
+}
+
+var browser$1 = {
+  nextTick: nextTick,
+  title: title,
+  browser: browser,
+  env: env,
+  argv: argv,
+  version: version,
+  versions: versions,
+  on: on,
+  addListener: addListener,
+  once: once,
+  off: off,
+  removeListener: removeListener,
+  removeAllListeners: removeAllListeners,
+  emit: emit,
+  binding: binding,
+  cwd: cwd,
+  chdir: chdir,
+  umask: umask,
+  hrtime: hrtime,
+  platform: platform,
+  release: release,
+  config: config,
+  uptime: uptime
+};
+
+var process = browser$1;
+
+var ReactReduxContext = /*#__PURE__*/React__default["default"].createContext(null);
+
+if (process.env.NODE_ENV !== 'production') {
+  ReactReduxContext.displayName = 'ReactRedux';
+}
+
+if (process.env.NODE_ENV !== 'production') {
+  ({
+    store: PropTypes__default["default"].shape({
+      subscribe: PropTypes__default["default"].func.isRequired,
+      dispatch: PropTypes__default["default"].func.isRequired,
+      getState: PropTypes__default["default"].func.isRequired
+    }),
+    context: PropTypes__default["default"].object,
+    children: PropTypes__default["default"].any
+  });
+}
+
+var FORWARD_REF_STATICS = {
+  '$$typeof': true,
+  render: true,
+  defaultProps: true,
+  displayName: true,
+  propTypes: true
+};
+var MEMO_STATICS = {
+  '$$typeof': true,
+  compare: true,
+  defaultProps: true,
+  displayName: true,
+  propTypes: true,
+  type: true
+};
+var TYPE_STATICS = {};
+TYPE_STATICS[reactIs__default["default"].ForwardRef] = FORWARD_REF_STATICS;
+TYPE_STATICS[reactIs__default["default"].Memo] = MEMO_STATICS;
+
+const checkPermission = ({
+  permission = '',
+  defaultValue = false,
+  permissions = {}
+}) => {
+  return lodash.result(permissions, permission, defaultValue);
+};
+const checkPermissionList = ({
+  permissionsList = [],
+  defaultValue = false,
+  permissions = {}
+}) => {
+  return !!permissionsList.map(permission => checkPermission({
+    permission,
+    defaultValue,
+    permissions
+  })).filter(v => !!v).length;
+};
+const usePermissions = ({
+  permission = '',
+  defaultValue = false,
+  user = {}
+}) => {
+  const permissions = React.useMemo(() => user?.role?.permissions || {}, [user]);
+  const value = React.useMemo(() => checkPermission({
+    permissions,
+    permission,
+    defaultValue
+  }), [permissions]);
+  return value;
+};
+
+exports.checkPermission = checkPermission;
+exports.checkPermissionList = checkPermissionList;
 exports.useFilters = useFilters;
 exports.useHeight = useHeight;
 exports.useIsMobile = useIsMobile;
@@ -1279,6 +1585,7 @@ exports.useLinearGradientAreaChart = useLinearGradientAreaChart;
 exports.useMapConfig = useMapConfig;
 exports.useMapOnExpandableWidget = useMapOnExpandableWidget;
 exports.usePagination = usePagination;
+exports.usePermissions = usePermissions;
 exports.useRadialBarChart = useRadialBarChart;
 exports.useSource = useSource;
 exports.useThemeLayout = useThemeLayout;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "datastake-daf",
-	"version": "0.6.535",
+	"version": "0.6.536",
 	"dependencies": {
 		"@ant-design/icons": "^5.2.5",
 		"@antv/g2": "^5.1.1",

package/src/@daf/hooks/usePermissions.js

@@ -1,20 +1,20 @@
 import { result } from "lodash";
+import { useMemo } from "react";
+import { useSelector } from "react-redux";
 
-export const checkPermission = ({ 
-  permission = '', 
-  defaultValue = false, 
-  permissions = {} 
-}) => {
+export const checkPermission = ({ permission = '', defaultValue = false, permissions = {} }) => {
   return result(permissions, permission, defaultValue);
-};
+}
 
-export const checkPermissionList = ({ 
-  permissionsList = [], 
-  defaultValue = false, 
-  permissions = {} 
-}) => {
+export const checkPermissionList = ({ permissionsList = [], defaultValue = false, permissions = {} }) => {
   return !!permissionsList
     .map((permission) => checkPermission({ permission, defaultValue, permissions }))
     .filter((v) => !!v)
     .length;
-};
+}
+
+export const usePermissions = ({ permission = '', defaultValue = false, user = {} }) => {
+  const permissions = useMemo(() => user?.role?.permissions || {}, [user]);
+  const value = useMemo(() => checkPermission({ permissions, permission, defaultValue }), [permissions]);
+  return value;
+};

package/src/hooks.js

@@ -7,4 +7,5 @@ export { default as useRadialBarChart } from "./@daf/hooks/useRadialBarChart";
 export { useMapConfig } from "./@daf/hooks/useMapHelper.js";
 export { useIsMobile } from "./@daf/hooks/useIsMobile";
 export { default as useSource } from "./@daf/hooks/useSources.js";
-export { useMapOnExpandableWidget } from "./@daf/hooks/useMapOnExpandableWidget";
+export { useMapOnExpandableWidget } from "./@daf/hooks/useMapOnExpandableWidget";
+export { checkPermission, checkPermissionList, usePermissions } from "./@daf/hooks/usePermissions";