el-crud-page 1.0.0

package/src/utils/kind-of.js

@@ -0,0 +1,129 @@
+var toString = Object.prototype.toString;
+
+export default function kindOf(val) {
+  if (val === void 0) return 'undefined';
+  if (val === null) return 'null';
+
+  var type = typeof val;
+  if (type === 'boolean') return 'boolean';
+  if (type === 'string') return 'string';
+  if (type === 'number') return 'number';
+  if (type === 'symbol') return 'symbol';
+  if (type === 'function') {
+    return isGeneratorFn(val) ? 'generatorfunction' : 'function';
+  }
+
+  if (isArray(val)) return 'array';
+  if (isBuffer(val)) return 'buffer';
+  if (isArguments(val)) return 'arguments';
+  if (isDate(val)) return 'date';
+  if (isError(val)) return 'error';
+  if (isRegexp(val)) return 'regexp';
+
+  switch (ctorName(val)) {
+    case 'Symbol': return 'symbol';
+    case 'Promise': return 'promise';
+
+    // Set, Map, WeakSet, WeakMap
+    case 'WeakMap': return 'weakmap';
+    case 'WeakSet': return 'weakset';
+    case 'Map': return 'map';
+    case 'Set': return 'set';
+
+    // 8-bit typed arrays
+    case 'Int8Array': return 'int8array';
+    case 'Uint8Array': return 'uint8array';
+    case 'Uint8ClampedArray': return 'uint8clampedarray';
+
+    // 16-bit typed arrays
+    case 'Int16Array': return 'int16array';
+    case 'Uint16Array': return 'uint16array';
+
+    // 32-bit typed arrays
+    case 'Int32Array': return 'int32array';
+    case 'Uint32Array': return 'uint32array';
+    case 'Float32Array': return 'float32array';
+    case 'Float64Array': return 'float64array';
+  }
+
+  if (isGeneratorObj(val)) {
+    return 'generator';
+  }
+
+  // Non-plain objects
+  type = toString.call(val);
+  switch (type) {
+    case '[object Object]': return 'object';
+    // iterators
+    case '[object Map Iterator]': return 'mapiterator';
+    case '[object Set Iterator]': return 'setiterator';
+    case '[object String Iterator]': return 'stringiterator';
+    case '[object Array Iterator]': return 'arrayiterator';
+  }
+
+  // other
+  return type.slice(8, -1).toLowerCase().replace(/\s/g, '');
+};
+
+function ctorName(val) {
+  return typeof val.constructor === 'function' ? val.constructor.name : null;
+}
+
+function isArray(val) {
+  if (Array.isArray) return Array.isArray(val);
+  return val instanceof Array;
+}
+
+function isError(val) {
+  return val instanceof Error || (typeof val.message === 'string' && val.constructor && typeof val.constructor.stackTraceLimit === 'number');
+}
+
+function isDate(val) {
+  if (val instanceof Date) return true;
+  return typeof val.toDateString === 'function'
+    && typeof val.getDate === 'function'
+    && typeof val.setDate === 'function';
+}
+
+function isRegexp(val) {
+  if (val instanceof RegExp) return true;
+  return typeof val.flags === 'string'
+    && typeof val.ignoreCase === 'boolean'
+    && typeof val.multiline === 'boolean'
+    && typeof val.global === 'boolean';
+}
+
+function isGeneratorFn(name, val) {
+  return ctorName(name) === 'GeneratorFunction';
+}
+
+function isGeneratorObj(val) {
+  return typeof val.throw === 'function'
+    && typeof val.return === 'function'
+    && typeof val.next === 'function';
+}
+
+function isArguments(val) {
+  try {
+    if (typeof val.length === 'number' && typeof val.callee === 'function') {
+      return true;
+    }
+  } catch (err) {
+    if (err.message.indexOf('callee') !== -1) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * If you need to support Safari 5-7 (8-10 yr-old browser),
+ * take a look at https://github.com/feross/is-buffer
+ */
+
+function isBuffer(val) {
+  if (val.constructor && typeof val.constructor.isBuffer === 'function') {
+    return val.constructor.isBuffer(val);
+  }
+  return false;
+}

package/src/utils/parse.js

@@ -0,0 +1,29 @@
+import { isString, isBoolean, isFunction } from "./index";
+
+/**
+ * 解析 hidden 参数的几个场景
+ * 1 Boolean
+ * 2 Function({ scope })
+ * 3 :[prop] is bind form[prop] value
+ * @param {*} value
+ */
+export default function (method, { value, scope, data = {} }) {
+	if (method === "hidden") {
+		if (isBoolean(value)) {
+			return value;
+		} else if (isString(value)) {
+			const prop = value.substring(1, value.length);
+
+			switch (value[0]) {
+				case "@":
+					return !scope[prop];
+				case ":":
+					return data[prop];
+			}
+		} else if (isFunction(value)) {
+			return value({ scope, ...data });
+		}
+
+		return false;
+	}
+}

package/src/utils/scroll-to.js

@@ -0,0 +1,58 @@
+Math.easeInOutQuad = function(t, b, c, d) {
+  t /= d / 2
+  if (t < 1) {
+    return c / 2 * t * t + b
+  }
+  t--
+  return -c / 2 * (t * (t - 2) - 1) + b
+}
+
+// requestAnimationFrame for Smart Animating http://goo.gl/sx5sts
+var requestAnimFrame = (function() {
+  return window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || function(callback) { window.setTimeout(callback, 1000 / 60) }
+})()
+
+/**
+ * Because it's so fucking difficult to detect the scrolling element, just move them all
+ * @param {number} amount
+ */
+function move(amount) {
+  document.documentElement.scrollTop = amount
+  document.body.parentNode.scrollTop = amount
+  document.body.scrollTop = amount
+}
+
+function position() {
+  return document.documentElement.scrollTop || document.body.parentNode.scrollTop || document.body.scrollTop
+}
+
+/**
+ * @param {number} to
+ * @param {number} duration
+ * @param {Function} callback
+ */
+export function scrollTo(to, duration, callback) {
+  const start = position()
+  const change = to - start
+  const increment = 20
+  let currentTime = 0
+  duration = (typeof (duration) === 'undefined') ? 500 : duration
+  var animateScroll = function() {
+    // increment the time
+    currentTime += increment
+    // find the value with the quadratic in-out easing function
+    var val = Math.easeInOutQuad(currentTime, start, change, duration)
+    // move the document.body
+    move(val)
+    // do the animation unless its over
+    if (currentTime < duration) {
+      requestAnimFrame(animateScroll)
+    } else {
+      if (callback && typeof (callback) === 'function') {
+        // the animation is done so lets callback
+        callback()
+      }
+    }
+  }
+  animateScroll()
+}

package/src/utils/shallow-clone.js

@@ -0,0 +1,79 @@
+/*!
+ * shallow-clone <https://github.com/jonschlinkert/shallow-clone>
+ *
+ * Copyright (c) 2015-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+import typeOf from "./kind-of";
+
+const valueOf = Symbol.prototype.valueOf;
+
+export default function clone(val, deep) {
+  switch (typeOf(val)) {
+    case 'array':
+      return val.slice();
+    case 'object':
+      return Object.assign({}, val);
+    case 'date':
+      return new val.constructor(Number(val));
+    case 'map':
+      return new Map(val);
+    case 'set':
+      return new Set(val);
+    case 'buffer':
+      return cloneBuffer(val);
+    case 'symbol':
+      return cloneSymbol(val);
+    case 'arraybuffer':
+      return cloneArrayBuffer(val);
+    case 'float32array':
+    case 'float64array':
+    case 'int16array':
+    case 'int32array':
+    case 'int8array':
+    case 'uint16array':
+    case 'uint32array':
+    case 'uint8clampedarray':
+    case 'uint8array':
+      return cloneTypedArray(val);
+    case 'regexp':
+      return cloneRegExp(val);
+    case 'error':
+      return Object.create(val);
+    default: {
+      return val;
+    }
+  }
+}
+
+function cloneRegExp(val) {
+  const flags = val.flags !== void 0 ? val.flags : (/\w+$/.exec(val) || void 0);
+  const re = new val.constructor(val.source, flags);
+  re.lastIndex = val.lastIndex;
+  return re;
+}
+
+function cloneArrayBuffer(val) {
+  const res = new val.constructor(val.byteLength);
+  new Uint8Array(res).set(new Uint8Array(val));
+  return res;
+}
+
+function cloneTypedArray(val, deep) {
+  return new val.constructor(val.buffer, val.byteOffset, val.length);
+}
+
+function cloneBuffer(val) {
+  const len = val.length;
+  const buf = Buffer.allocUnsafe ? Buffer.allocUnsafe(len) : Buffer.from(len);
+  val.copy(buf);
+  return buf;
+}
+
+function cloneSymbol(val) {
+  return valueOf ? Object(valueOf.call(val)) : {};
+}
+ 

package/src/utils/value-hook.js

@@ -0,0 +1,97 @@
+import { isArray, isFunction, isObject, isString } from "./index";
+
+export const format = {
+	number(value) {
+        let result 
+        if( isArray(value) ){
+            result = value.map(Number).map(item => isNaN(item) ? undefined : item)
+        }else{
+            result = Number(value) 
+            if(isNaN(result)){
+                result = undefined
+            }
+        }
+        return result
+		
+	},
+	string(value) {
+		return isArray(value) ? value.map(String) : String(value);
+	},
+	split(value) {
+		return isString(value) ? value.split(",").filter(Boolean) : value;
+	},
+	join(value) {
+		return isArray(value) ? value.join(",") : value;
+	},
+	boolean(value) {
+		return Boolean(value);
+	},
+	booleanNumber(value) {
+		return Boolean(value) ? 1 : 0;
+	},
+	datetimerange(value, form, method) {
+		if (method == "bind") {
+			return [form.startTime, form.endTime];
+		} else {
+			const [startTime, endTime] = value || [];
+			form.startTime = startTime;
+			form.endTime = endTime;
+			return undefined;
+		}
+	},
+	splitJoin(value, _, method) {
+		if (method == "bind") {
+			return isString(value) ? value.split(",").filter(Boolean) : value;
+		} else {
+			return isArray(value) ? value.join(",") : value;
+		}
+	}
+};
+
+function parse(method, { value, pipe, form }) {
+	if (!pipe) {
+		return value;
+	}
+
+	let pipes = [];
+
+	if (isString(pipe)) {
+		if (format[pipe]) {
+			pipes = [pipe];
+		} else {
+			console.error(`${pipe} is not found.`);
+			return value;
+		}
+	} else if (isArray(pipe)) {
+		pipes = pipe;
+	} else if (isObject(pipe)) {
+		pipes = isArray(pipe[method]) ? pipe[method] : [pipe[method]];
+	} else if (isFunction(pipe)) {
+		pipes = [pipe];
+	} else {
+		console.error(`Hook data error!`);
+		return value;
+	}
+
+	let d = value;
+
+	pipes.forEach((e) => {
+		if (isString(e)) {
+			d = format[e](d, form, method);
+		} else if (isFunction(e)) {
+			d = e(d, form);
+		}
+	});
+
+	return d;
+}
+
+export default {
+	bind(value, pipe, form) {
+		return parse("bind", { value, pipe, form });
+	},
+
+	submit(value, pipe, form) {
+		return parse("submit", { value, pipe, form });
+	}
+};

package/src/utils/vnode.jsx

@@ -0,0 +1,215 @@
+import { isFunction, isString, cloneDeep, isObject } from "./index";
+import Vue from "vue";
+
+// ...删除固定创建的 __inst ...
+const __vue = Vue   // Vue
+
+/**
+ * Parse JSX, filter params
+ * options 增加 inst 参数，代表外部传入的 Vue 实例
+ * @param {*} vnode
+ * @param {{inst, scope, prop, children, $scopedSlots}} options
+ */
+const parse_jsx = (vnode, options = {}) => {
+	const { inst, scope, prop, $scopedSlots, children = [] } = options;
+	const h = inst.$createElement;
+
+	if (vnode.name.indexOf("slot-") == 0) {
+		let rn = $scopedSlots[vnode.name];
+
+		if (rn) {
+			return rn({ scope });
+		} else {
+			return "错误";
+		}
+	}
+
+	if (vnode.render) {
+		if (!inst.$root.$options.components[vnode.name]) {
+			__vue.component(vnode.name, cloneDeep(vnode));
+		}
+
+		// Avoid props prompts { type:null }
+		delete vnode.props;
+	}
+
+	const keys = [
+		"class",
+		"style",
+		"props",
+		"attrs",
+		"domProps",
+		"on",
+		"nativeOn",
+		"directives",
+		"scopedSlots",
+		"slot",
+		"key",
+		"ref",
+		"refInFor"
+	];
+
+	// Avoid loop update
+	let data = cloneDeep(vnode);
+
+	for (let i in data) {
+		if (!keys.includes(i)) {
+			delete data[i];
+		}
+	}
+
+	if (scope) {
+		if (!data.attrs) {
+			data.attrs = {};
+		}
+
+		if (!data.on) {
+			data.on = {};
+		}
+
+		if (!data.props) {
+			data.props = {};
+		}
+
+		// 添加作用域
+		data.props.scope = scope
+
+		// 输入事件
+		const onInput = data.on.input
+
+		// 设置默认值
+		data.attrs.value = scope[prop];
+
+		// 监听输入事件
+		data.on.input = (val) => {
+			inst.$set(scope, prop, val);
+			if (onInput) {
+				onInput(val)
+			}
+		};
+	} 
+	return h(vnode.name, cloneDeep(data), children);
+};
+
+/**
+ * Render vNode
+ * options 允许 inst 为空，通过调用者的 this 获取 Vue 实例
+ * @param {*} vnode
+ * @param {{inst?, prop, scope, $scopedSlots}} options
+ */
+export function renderNode(vnode, options) {
+	// 如果 options.inst 为空，则尝试用调用者上下文的 this
+	const { prop, scope, $scopedSlots } = options;
+	const inst = options.inst || this;
+	const h = inst.$createElement;
+	 
+	if (!vnode) {
+		return null;
+	}
+
+	// When slot or tagName
+	if (isString(vnode)) {
+		return parse_jsx({ name: vnode }, { inst,prop, scope, $scopedSlots });
+	}
+
+	// When customeize render function
+	if (isFunction(vnode)) {
+		return vnode({ scope, h });
+	}
+	// When jsx
+	if (isObject(vnode)) {
+		if( isObject(  vnode.name ) ){
+			let component = vnode.name
+			let curComponent = Object.values(inst.$options.components).find(item=>item == vnode)
+			if( curComponent ){
+				vnode.name = curComponent.name ;
+			}else{
+				const componentName = component.name || "component_" + Math.random().toString(36).substr(2, 9);
+				inst.$options.components[ componentName ] = component;
+				vnode.name = componentName;
+				console.log( componentName )
+			}
+		}
+		
+		if (vnode.context) {
+			return vnode;
+		}
+
+		if (vnode.name) {
+			// Handle general component
+			const keys = ["el-select", "el-radio-group", "el-checkbox-group"];
+			if (keys.includes(vnode.name)) {
+				let options = vnode.options;
+				if( isFunction( options ) ){
+					options = options( scope );
+				}
+				
+				// Append component children
+				const children = (options || []).map((e, i) => {
+					if (vnode.name === "el-select") {
+						let label, value;
+
+						if (isString(e)) {
+							label = value = e;
+						} else if (isObject(e)) {
+							label = e.label;
+							value = e.value;
+						} else {
+							return "错误";
+						}
+
+						return (
+							<el-option
+								{...{
+									props: {
+										key: i,
+										label,
+										value,
+										...e.props
+									}
+								}}
+							/>
+						);
+					} else if (vnode.name === "el-radio-group") {
+						return (
+							<el-radio
+								{...{
+									props: {
+										key: i,
+										label: e.value,
+										...e.props
+									}
+								}}>
+								{e.label}
+							</el-radio>
+						);
+					} else if (vnode.name === "el-checkbox-group") {
+						if(  typeof scope[prop]==='undefined' ){ 
+							inst.$set(scope, prop, [])
+						}
+
+						return (
+							<el-checkbox
+								{...{
+									props: {
+										key: i,
+										label: e.value,
+										...e.props
+									}
+								}}>
+								{e.label}
+							</el-checkbox>
+						);
+					} else {
+						return null;
+					}
+				});
+				return parse_jsx(vnode, { inst, prop, scope, children });
+			} else {
+				return parse_jsx(vnode, { inst, prop, scope, $scopedSlots });
+			}
+		} else {
+			return "错误";
+		}
+	}
+}