@daoyi/nmtl-ui 2.0.1-beta.44 → 2.0.1-beta.46

package/lib/utils/historyAppendSearch.js

@@ -1 +1,502 @@
-import{b as r,c as e}from"./_rollupPluginBabelHelpers-a6e0e6e3.js";import o from"prop-types";import{q as s}from"./vendor-3ec75cc9.js";var a=["history"],i=function(o){var i=o.history,p=r(o,a);if(i){var t=i.location.search;i.replace({search:s.stringify(e(e({},s.parse(t)),p))})}else console.error("error","historyAppendSearch needs history")};i.propTypes={history:o.objectOf(o.any).isRequired};export{i as default};
+import { b as _objectWithoutProperties, c as _objectSpread2 } from './_rollupPluginBabelHelpers-a6e0e6e3.js';
+import PropTypes from 'prop-types';
+
+var queryString = {};
+
+var strictUriEncode = str => encodeURIComponent(str).replace(/[!'()*]/g, x => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);
+
+var token = '%[a-f0-9]{2}';
+var singleMatcher = new RegExp(token, 'gi');
+var multiMatcher = new RegExp('(' + token + ')+', 'gi');
+
+function decodeComponents(components, split) {
+	try {
+		// Try to decode the entire string first
+		return decodeURIComponent(components.join(''));
+	} catch (err) {
+		// Do nothing
+	}
+
+	if (components.length === 1) {
+		return components;
+	}
+
+	split = split || 1;
+
+	// Split the array in 2 parts
+	var left = components.slice(0, split);
+	var right = components.slice(split);
+
+	return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
+}
+
+function decode(input) {
+	try {
+		return decodeURIComponent(input);
+	} catch (err) {
+		var tokens = input.match(singleMatcher);
+
+		for (var i = 1; i < tokens.length; i++) {
+			input = decodeComponents(tokens, i).join('');
+
+			tokens = input.match(singleMatcher);
+		}
+
+		return input;
+	}
+}
+
+function customDecodeURIComponent(input) {
+	// Keep track of all the replacements and prefill the map with the `BOM`
+	var replaceMap = {
+		'%FE%FF': '\uFFFD\uFFFD',
+		'%FF%FE': '\uFFFD\uFFFD'
+	};
+
+	var match = multiMatcher.exec(input);
+	while (match) {
+		try {
+			// Decode as big chunks as possible
+			replaceMap[match[0]] = decodeURIComponent(match[0]);
+		} catch (err) {
+			var result = decode(match[0]);
+
+			if (result !== match[0]) {
+				replaceMap[match[0]] = result;
+			}
+		}
+
+		match = multiMatcher.exec(input);
+	}
+
+	// Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else
+	replaceMap['%C2'] = '\uFFFD';
+
+	var entries = Object.keys(replaceMap);
+
+	for (var i = 0; i < entries.length; i++) {
+		// Replace all decoded components
+		var key = entries[i];
+		input = input.replace(new RegExp(key, 'g'), replaceMap[key]);
+	}
+
+	return input;
+}
+
+var decodeUriComponent = function (encodedURI) {
+	if (typeof encodedURI !== 'string') {
+		throw new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');
+	}
+
+	try {
+		encodedURI = encodedURI.replace(/\+/g, ' ');
+
+		// Try the built in decoder first
+		return decodeURIComponent(encodedURI);
+	} catch (err) {
+		// Fallback to a more advanced decoder
+		return customDecodeURIComponent(encodedURI);
+	}
+};
+
+var splitOnFirst = (string, separator) => {
+	if (!(typeof string === 'string' && typeof separator === 'string')) {
+		throw new TypeError('Expected the arguments to be of type `string`');
+	}
+
+	if (separator === '') {
+		return [string];
+	}
+
+	const separatorIndex = string.indexOf(separator);
+
+	if (separatorIndex === -1) {
+		return [string];
+	}
+
+	return [
+		string.slice(0, separatorIndex),
+		string.slice(separatorIndex + separator.length)
+	];
+};
+
+(function (exports) {
+	const strictUriEncode$1 = strictUriEncode;
+	const decodeComponent = decodeUriComponent;
+	const splitOnFirst$1 = splitOnFirst;
+
+	const isNullOrUndefined = value => value === null || value === undefined;
+
+	function encoderForArrayFormat(options) {
+		switch (options.arrayFormat) {
+			case 'index':
+				return key => (result, value) => {
+					const index = result.length;
+
+					if (
+						value === undefined ||
+						(options.skipNull && value === null) ||
+						(options.skipEmptyString && value === '')
+					) {
+						return result;
+					}
+
+					if (value === null) {
+						return [...result, [encode(key, options), '[', index, ']'].join('')];
+					}
+
+					return [
+						...result,
+						[encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join('')
+					];
+				};
+
+			case 'bracket':
+				return key => (result, value) => {
+					if (
+						value === undefined ||
+						(options.skipNull && value === null) ||
+						(options.skipEmptyString && value === '')
+					) {
+						return result;
+					}
+
+					if (value === null) {
+						return [...result, [encode(key, options), '[]'].join('')];
+					}
+
+					return [...result, [encode(key, options), '[]=', encode(value, options)].join('')];
+				};
+
+			case 'comma':
+			case 'separator':
+				return key => (result, value) => {
+					if (value === null || value === undefined || value.length === 0) {
+						return result;
+					}
+
+					if (result.length === 0) {
+						return [[encode(key, options), '=', encode(value, options)].join('')];
+					}
+
+					return [[result, encode(value, options)].join(options.arrayFormatSeparator)];
+				};
+
+			default:
+				return key => (result, value) => {
+					if (
+						value === undefined ||
+						(options.skipNull && value === null) ||
+						(options.skipEmptyString && value === '')
+					) {
+						return result;
+					}
+
+					if (value === null) {
+						return [...result, encode(key, options)];
+					}
+
+					return [...result, [encode(key, options), '=', encode(value, options)].join('')];
+				};
+		}
+	}
+
+	function parserForArrayFormat(options) {
+		let result;
+
+		switch (options.arrayFormat) {
+			case 'index':
+				return (key, value, accumulator) => {
+					result = /\[(\d*)\]$/.exec(key);
+
+					key = key.replace(/\[\d*\]$/, '');
+
+					if (!result) {
+						accumulator[key] = value;
+						return;
+					}
+
+					if (accumulator[key] === undefined) {
+						accumulator[key] = {};
+					}
+
+					accumulator[key][result[1]] = value;
+				};
+
+			case 'bracket':
+				return (key, value, accumulator) => {
+					result = /(\[\])$/.exec(key);
+					key = key.replace(/\[\]$/, '');
+
+					if (!result) {
+						accumulator[key] = value;
+						return;
+					}
+
+					if (accumulator[key] === undefined) {
+						accumulator[key] = [value];
+						return;
+					}
+
+					accumulator[key] = [].concat(accumulator[key], value);
+				};
+
+			case 'comma':
+			case 'separator':
+				return (key, value, accumulator) => {
+					const isArray = typeof value === 'string' && value.split('').indexOf(options.arrayFormatSeparator) > -1;
+					const newValue = isArray ? value.split(options.arrayFormatSeparator).map(item => decode(item, options)) : value === null ? value : decode(value, options);
+					accumulator[key] = newValue;
+				};
+
+			default:
+				return (key, value, accumulator) => {
+					if (accumulator[key] === undefined) {
+						accumulator[key] = value;
+						return;
+					}
+
+					accumulator[key] = [].concat(accumulator[key], value);
+				};
+		}
+	}
+
+	function validateArrayFormatSeparator(value) {
+		if (typeof value !== 'string' || value.length !== 1) {
+			throw new TypeError('arrayFormatSeparator must be single character string');
+		}
+	}
+
+	function encode(value, options) {
+		if (options.encode) {
+			return options.strict ? strictUriEncode$1(value) : encodeURIComponent(value);
+		}
+
+		return value;
+	}
+
+	function decode(value, options) {
+		if (options.decode) {
+			return decodeComponent(value);
+		}
+
+		return value;
+	}
+
+	function keysSorter(input) {
+		if (Array.isArray(input)) {
+			return input.sort();
+		}
+
+		if (typeof input === 'object') {
+			return keysSorter(Object.keys(input))
+				.sort((a, b) => Number(a) - Number(b))
+				.map(key => input[key]);
+		}
+
+		return input;
+	}
+
+	function removeHash(input) {
+		const hashStart = input.indexOf('#');
+		if (hashStart !== -1) {
+			input = input.slice(0, hashStart);
+		}
+
+		return input;
+	}
+
+	function getHash(url) {
+		let hash = '';
+		const hashStart = url.indexOf('#');
+		if (hashStart !== -1) {
+			hash = url.slice(hashStart);
+		}
+
+		return hash;
+	}
+
+	function extract(input) {
+		input = removeHash(input);
+		const queryStart = input.indexOf('?');
+		if (queryStart === -1) {
+			return '';
+		}
+
+		return input.slice(queryStart + 1);
+	}
+
+	function parseValue(value, options) {
+		if (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === 'string' && value.trim() !== '')) {
+			value = Number(value);
+		} else if (options.parseBooleans && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {
+			value = value.toLowerCase() === 'true';
+		}
+
+		return value;
+	}
+
+	function parse(input, options) {
+		options = Object.assign({
+			decode: true,
+			sort: true,
+			arrayFormat: 'none',
+			arrayFormatSeparator: ',',
+			parseNumbers: false,
+			parseBooleans: false
+		}, options);
+
+		validateArrayFormatSeparator(options.arrayFormatSeparator);
+
+		const formatter = parserForArrayFormat(options);
+
+		// Create an object with no prototype
+		const ret = Object.create(null);
+
+		if (typeof input !== 'string') {
+			return ret;
+		}
+
+		input = input.trim().replace(/^[?#&]/, '');
+
+		if (!input) {
+			return ret;
+		}
+
+		for (const param of input.split('&')) {
+			let [key, value] = splitOnFirst$1(options.decode ? param.replace(/\+/g, ' ') : param, '=');
+
+			// Missing `=` should be `null`:
+			// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
+			value = value === undefined ? null : ['comma', 'separator'].includes(options.arrayFormat) ? value : decode(value, options);
+			formatter(decode(key, options), value, ret);
+		}
+
+		for (const key of Object.keys(ret)) {
+			const value = ret[key];
+			if (typeof value === 'object' && value !== null) {
+				for (const k of Object.keys(value)) {
+					value[k] = parseValue(value[k], options);
+				}
+			} else {
+				ret[key] = parseValue(value, options);
+			}
+		}
+
+		if (options.sort === false) {
+			return ret;
+		}
+
+		return (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {
+			const value = ret[key];
+			if (Boolean(value) && typeof value === 'object' && !Array.isArray(value)) {
+				// Sort object keys, not values
+				result[key] = keysSorter(value);
+			} else {
+				result[key] = value;
+			}
+
+			return result;
+		}, Object.create(null));
+	}
+
+	exports.extract = extract;
+	exports.parse = parse;
+
+	exports.stringify = (object, options) => {
+		if (!object) {
+			return '';
+		}
+
+		options = Object.assign({
+			encode: true,
+			strict: true,
+			arrayFormat: 'none',
+			arrayFormatSeparator: ','
+		}, options);
+
+		validateArrayFormatSeparator(options.arrayFormatSeparator);
+
+		const shouldFilter = key => (
+			(options.skipNull && isNullOrUndefined(object[key])) ||
+			(options.skipEmptyString && object[key] === '')
+		);
+
+		const formatter = encoderForArrayFormat(options);
+
+		const objectCopy = {};
+
+		for (const key of Object.keys(object)) {
+			if (!shouldFilter(key)) {
+				objectCopy[key] = object[key];
+			}
+		}
+
+		const keys = Object.keys(objectCopy);
+
+		if (options.sort !== false) {
+			keys.sort(options.sort);
+		}
+
+		return keys.map(key => {
+			const value = object[key];
+
+			if (value === undefined) {
+				return '';
+			}
+
+			if (value === null) {
+				return encode(key, options);
+			}
+
+			if (Array.isArray(value)) {
+				return value
+					.reduce(formatter(key), [])
+					.join('&');
+			}
+
+			return encode(key, options) + '=' + encode(value, options);
+		}).filter(x => x.length > 0).join('&');
+	};
+
+	exports.parseUrl = (input, options) => {
+		return {
+			url: removeHash(input).split('?')[0] || '',
+			query: parse(extract(input), options)
+		};
+	};
+
+	exports.stringifyUrl = (input, options) => {
+		const url = removeHash(input.url).split('?')[0] || '';
+		const queryFromUrl = exports.extract(input.url);
+		const parsedQueryFromUrl = exports.parse(queryFromUrl);
+		const hash = getHash(input.url);
+		const query = Object.assign(parsedQueryFromUrl, input.query);
+		let queryString = exports.stringify(query, options);
+		if (queryString) {
+			queryString = `?${queryString}`;
+		}
+
+		return `${url}${queryString}${hash}`;
+	};
+} (queryString));
+
+var _excluded = ["history"];
+var historyAppendSearch = function historyAppendSearch(_ref) {
+  var history = _ref.history,
+    rest = _objectWithoutProperties(_ref, _excluded);
+  if (history) {
+    var search = history.location.search;
+    history.replace({
+      search: queryString.stringify(_objectSpread2(_objectSpread2({}, queryString.parse(search)), rest))
+    });
+  } else {
+    console.error('error', 'historyAppendSearch needs history');
+  }
+};
+historyAppendSearch.propTypes = {
+  /** react-router-dom 的 history */
+  history: PropTypes.objectOf(PropTypes.any).isRequired
+};
+
+export { historyAppendSearch as default };

package/lib/utils/isDevelopMode.js

@@ -1 +1,5 @@
-var o=function(){return"localhost"===window.location||!1};export{o as default};
+var isDevelopMode = function isDevelopMode() {
+  return window.location === 'localhost' || "production" === 'development';
+};
+
+export { isDevelopMode as default };

package/lib/utils/parseYMD.js

@@ -1 +1,36 @@
-var t=function(t){var a="",n=t.split("-"),r=parseInt(n[0],10);r<=0?r=1911:a=r.toString();var o=parseInt(n[1],10);o<=0||o>12?o=1:a="".concat(a,"-").concat(o.toString());var c=parseInt(n[2],10);return c<=0||c>31?c=1:a="".concat(a,"-").concat(c.toString()),{year:r,month:o,day:c,displayDate:a}};export{t as default};
+var parseYMD = function parseYMD(date) {
+  var displayDate = '';
+  var ymd = date.split('-');
+
+  // year
+  var year = parseInt(ymd[0], 10);
+  if (year <= 0) {
+    year = 1911;
+  } else {
+    displayDate = year.toString();
+  }
+
+  // month
+  var month = parseInt(ymd[1], 10);
+  if (month <= 0 || month > 12) {
+    month = 1;
+  } else {
+    displayDate = "".concat(displayDate, "-").concat(month.toString());
+  }
+
+  // day
+  var day = parseInt(ymd[2], 10);
+  if (day <= 0 || day > 31) {
+    day = 1;
+  } else {
+    displayDate = "".concat(displayDate, "-").concat(day.toString());
+  }
+  return {
+    year: year,
+    month: month,
+    day: day,
+    displayDate: displayDate
+  };
+};
+
+export { parseYMD as default };

package/lib/utils/removeDuplicateItem.js

@@ -1 +1,11 @@
-var r=function(r){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"value";return Array.isArray(r)?r.filter((function(r,t,e){return e.findIndex((function(t){return t[n]===r[n]}))===t})):[]};export{r as default};
+var removeDuplicateItem = function removeDuplicateItem(array) {
+  var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'value';
+  if (Array.isArray(array)) return array.filter(function (v, i, a) {
+    return a.findIndex(function (t) {
+      return t[key] === v[key];
+    }) === i;
+  });
+  return [];
+};
+
+export { removeDuplicateItem as default };

package/lib/utils/sendEmail.js

@@ -1 +1,39 @@
-import r from"axios";var e=function(e,t,a){var o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:5e3;r.defaults.timeout=o;try{return r.post(t,{sendMail:e}).then((function(r){return a({state:r&&200===r.status})})).catch((function(r){return console.error("api:axios:catch:error: ",r.message),{state:!1,error:r.message}}))}catch(r){return console.error("api:axios:try:catch:error: ",r.message),{state:!1,error:r.message}}};export{e as default};
+import axios from 'axios';
+
+// const sendMail = {
+// 	from: "orient.cc.noreply@gmail.com",
+// 	to: email,
+// 	subject: `ATC_${card_id}`+" card status has been changed (Orient-CC)",
+// 	text: context,
+// };
+//
+// apiUrl: "https://api.daoyidh.com/mail"
+var sendEmail = function sendEmail(sendMail, apiUrl, onSuccess) {
+  var timeout = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 5000;
+  // timeout
+  axios.defaults.timeout = timeout;
+  try {
+    // axios api
+    return axios.post(apiUrl, {
+      sendMail: sendMail
+    }).then(function (res) {
+      return onSuccess({
+        state: res && res.status === 200
+      });
+    }).catch(function (err) {
+      console.error('api:axios:catch:error: ', err.message);
+      return {
+        state: false,
+        error: err.message
+      };
+    });
+  } catch (err) {
+    console.error('api:axios:try:catch:error: ', err.message);
+    return {
+      state: false,
+      error: err.message
+    };
+  }
+};
+
+export { sendEmail as default };

package/lib/utils/snaDefine-6a2bcd94.js

@@ -1 +1,5 @@
-var a={mainNode:"mainNode"};export{a as s};
+var snaDefine = {
+  mainNode: 'mainNode'
+};
+
+export { snaDefine as s };

package/lib/utils/snaDefine.js

@@ -1 +1 @@
-export{s as default}from"./snaDefine-6a2bcd94.js";
+export { s as default } from './snaDefine-6a2bcd94.js';

package/lib/utils/snaPreProcess.js

@@ -1 +1,84 @@
-import{_ as e}from"./_rollupPluginBabelHelpers-a6e0e6e3.js";import{s as r}from"./snaDefine-6a2bcd94.js";var n=function(n){var i=n.mainNodes,a=n.snaData;if(!(i&&Array.isArray(i)&&a&&Array.isArray(a)))return console.log("ERROR: wrong input data.",i,a),{nodes:[],links:[]};var t=[];a.forEach((function(e){var n=e.sourceId,a=e.sourceType,d=e.source,o=e.sourceHide,s=e.targetId,u=e.targetType,f=e.target,c=e.targetHide;t.find((function(r){return r.id===e.sourceId}))||t.push({name:d,id:n,type:-1!==i.indexOf(n)?r.mainNode:a,hasClick:-1===i.indexOf(n),hide:o||"0"}),t.find((function(r){return r.id===e.targetId}))||t.push({name:f,id:s,type:-1!==i.indexOf(s)?r.mainNode:u,hasClick:-1===i.indexOf(s),hide:c||"0"})}));var d=e(new Set(t.map((function(e){return JSON.stringify(e)})))).map((function(e){return JSON.parse(e)})),o=[];return a.forEach((function(e){var r=e.sourceId,n=e.targetId;o.push({target:d.findIndex((function(e){return n===e.id})),source:d.findIndex((function(e){return r===e.id}))})})),{nodes:d,links:o}};export{n as default};
+import { _ as _toConsumableArray } from './_rollupPluginBabelHelpers-a6e0e6e3.js';
+import { s as snaDefine } from './snaDefine-6a2bcd94.js';
+
+var snaPreProcess = function snaPreProcess(_ref) {
+  var mainNodes = _ref.mainNodes,
+    snaData = _ref.snaData;
+  if (!mainNodes || !Array.isArray(mainNodes) || !snaData || !Array.isArray(snaData)) {
+    // eslint-disable-next-line no-console
+    console.log('ERROR: wrong input data.', mainNodes, snaData);
+    return {
+      nodes: [],
+      links: []
+    };
+  }
+
+  // 將所有source、target都建成node 並給予node的type好區分在圖上的圓圈大小與顏色
+  var nodes = [];
+  snaData.forEach(function (item) {
+    var sourceId = item.sourceId,
+      sourceType = item.sourceType,
+      source = item.source,
+      sourceHide = item.sourceHide,
+      targetId = item.targetId,
+      targetType = item.targetType,
+      target = item.target,
+      targetHide = item.targetHide;
+
+    // 避免出現無關聯的 node
+    var foundSrc = nodes.find(function (n) {
+      return n.id === item.sourceId;
+    });
+    if (!foundSrc) {
+      nodes.push({
+        name: source,
+        id: sourceId,
+        type: mainNodes.indexOf(sourceId) !== -1 ? snaDefine.mainNode : sourceType,
+        hasClick: mainNodes.indexOf(sourceId) === -1,
+        hide: sourceHide || '0'
+      });
+    }
+
+    // 避免出現無關聯的 node
+    var foundTar = nodes.find(function (n) {
+      return n.id === item.targetId;
+    });
+    if (!foundTar) {
+      nodes.push({
+        name: target,
+        id: targetId,
+        type: mainNodes.indexOf(targetId) !== -1 ? snaDefine.mainNode : targetType,
+        hasClick: mainNodes.indexOf(targetId) === -1,
+        hide: targetHide || '0'
+      });
+    }
+  });
+
+  // 刪除重複的node
+  var uniqueNodes = _toConsumableArray(new Set(nodes.map(function (item) {
+    return JSON.stringify(item);
+  }))).map(function (item) {
+    return JSON.parse(item);
+  });
+
+  // 把有關係的node建立link
+  var links = [];
+  snaData.forEach(function (item) {
+    var sourceId = item.sourceId,
+      targetId = item.targetId;
+    links.push({
+      target: uniqueNodes.findIndex(function (uniqueNode) {
+        return targetId === uniqueNode.id;
+      }),
+      source: uniqueNodes.findIndex(function (uniqueNode) {
+        return sourceId === uniqueNode.id;
+      })
+    });
+  });
+  return {
+    nodes: uniqueNodes,
+    links: links
+  };
+};
+
+export { snaPreProcess as default };