@king-design/vue 2.0.0-beta.0

package/components/upload/useShowImage.d.ts

@@ -0,0 +1,10 @@
+import { UploadFile } from './';
+export declare function useShowImage(): {
+    show: (file: UploadFile) => void;
+    close: () => void;
+    image: import("../../hooks/useState").State<UploadFile | null>;
+    isShow: import("../../hooks/useState").State<boolean>;
+};
+
+
+export {normalize} from 'intact-vue-next';

package/components/upload/useShowImage.js

@@ -0,0 +1,25 @@
+import { useInstance } from 'intact-vue-next';
+import { useState } from '../../hooks/useState';
+export function useShowImage() {
+  var instance = useInstance();
+  var isShow = useState(false);
+  var image = useState(null);
+
+  function show(file) {
+    isShow.set(true);
+    image.set(file);
+  }
+
+  function close() {
+    isShow.set(false);
+  }
+
+  return {
+    show: show,
+    close: close,
+    image: image,
+    isShow: isShow
+  };
+}
+
+export {normalize} from 'intact-vue-next';

package/components/upload/useUpload.d.ts

@@ -0,0 +1,12 @@
+import { UploadFile } from './';
+export declare enum UploadFileStatus {
+    Done = 0,
+    Ready = 1,
+    NotReady = 2,
+    Uploading = 3,
+    Error = 4
+}
+export declare function useUpload(): (file: UploadFile) => Promise<boolean>;
+
+
+export {normalize} from 'intact-vue-next';

package/components/upload/useUpload.js

@@ -0,0 +1,121 @@
+import _extends from "@babel/runtime-corejs3/helpers/extends";
+import _asyncToGenerator from "@babel/runtime-corejs3/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime-corejs3/regenerator";
+import _sliceInstanceProperty from "@babel/runtime-corejs3/core-js/instance/slice";
+import _spliceInstanceProperty from "@babel/runtime-corejs3/core-js/instance/splice";
+import { useInstance } from 'intact-vue-next';
+import { request } from './ajaxUploader';
+import { isFunction } from 'intact-shared';
+export var UploadFileStatus;
+
+(function (UploadFileStatus) {
+  UploadFileStatus[UploadFileStatus["Done"] = 0] = "Done";
+  UploadFileStatus[UploadFileStatus["Ready"] = 1] = "Ready";
+  UploadFileStatus[UploadFileStatus["NotReady"] = 2] = "NotReady";
+  UploadFileStatus[UploadFileStatus["Uploading"] = 3] = "Uploading";
+  UploadFileStatus[UploadFileStatus["Error"] = 4] = "Error";
+})(UploadFileStatus || (UploadFileStatus = {}));
+
+export function useUpload() {
+  var instance = useInstance();
+
+  function upload(_x) {
+    return _upload.apply(this, arguments);
+  }
+
+  function _upload() {
+    _upload = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(file) {
+      var _extends2;
+
+      var beforeUpload, files, shouldUpload, newFiles, index, _instance$get, data, action, headers, name, withCredentials;
+
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              beforeUpload = instance.get('beforeUpload');
+              files = instance.get('files');
+              shouldUpload = true;
+
+              if (!beforeUpload) {
+                _context.next = 7;
+                break;
+              }
+
+              _context.next = 6;
+              return beforeUpload(file, files);
+
+            case 6:
+              shouldUpload = _context.sent;
+
+            case 7:
+              if (shouldUpload) {
+                _context.next = 12;
+                break;
+              }
+
+              newFiles = _sliceInstanceProperty(files).call(files, 0);
+              index = newFiles.indexOf(file);
+
+              if (index > -1) {
+                _spliceInstanceProperty(newFiles).call(newFiles, index, 1);
+
+                instance.set({
+                  files: newFiles
+                });
+              }
+
+              return _context.abrupt("return", false);
+
+            case 12:
+              _instance$get = instance.get(), data = _instance$get.data, action = _instance$get.action, headers = _instance$get.headers, name = _instance$get.name, withCredentials = _instance$get.withCredentials;
+              file.request = request({
+                action: action,
+                headers: headers,
+                withCredentials: withCredentials,
+                data: _extends((_extends2 = {}, _extends2[name || file.name] = file.raw, _extends2), isFunction(data) ? data(file) : data || {}),
+                onProgress: function onProgress(e, percent, xhr) {
+                  _onProgress(e, percent, file, xhr);
+                },
+                onError: function onError(e) {
+                  _onError(e, file);
+                },
+                onSuccess: function onSuccess(res, xhr) {
+                  _onSuccess(res, file, xhr);
+                }
+              });
+              return _context.abrupt("return", true);
+
+            case 15:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+    return _upload.apply(this, arguments);
+  }
+
+  function _onProgress(e, percent, file, xhr) {
+    file.status = UploadFileStatus.Uploading;
+    file.percent = percent;
+    instance.forceUpdate();
+    instance.trigger('progress', e, xhr, file, instance.get('files'));
+  }
+
+  function _onError(e, file) {
+    file.status = UploadFileStatus.Error;
+    instance.forceUpdate();
+    instance.trigger('error', e, file, instance.get('files'));
+  }
+
+  function _onSuccess(res, file, xhr) {
+    file.status = UploadFileStatus.Done;
+    instance.forceUpdate();
+    instance.trigger('success', res, xhr, file, instance.get('files'));
+  }
+
+  return upload;
+}
+
+export {normalize} from 'intact-vue-next';

package/components/utils.d.ts

@@ -0,0 +1,42 @@
+import { Component, VNode, Children, VNodeComponentClass, ComponentConstructor } from 'intact-vue-next';
+export declare function bind<T extends Function>(target: any, key: string, descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T>;
+export declare function addStyle(style: string | Record<string, string | null> | undefined, extra: Record<string, string | null>): string | Record<string, string | null>;
+export declare function kebabCase(word: string): string;
+export declare function isTextChildren(o: any): boolean;
+export declare function isTextVNode(o: VNode): boolean;
+export declare function isTextBlock(o: any): boolean;
+export declare function isStringOrNumberNotEmpty(o: any): o is string | number;
+export declare function getRestProps<T>(component: Component<T>, props?: import("intact").Props<T, Component<T, {}, {}, {}>>): Partial<T>;
+export declare function isExternalLink(to?: string): boolean;
+export declare function clamp(number: number, lower: number, upper: number): number;
+export declare function stopPropagation(e: Event): void;
+export declare type ValidVNode = VNode | string | number;
+export declare type MapCallback<T> = (vNode: ValidVNode, index: number) => T;
+export declare function findChildren(children: Children, callback: MapCallback<boolean>): ValidVNode | undefined;
+export declare function mapChildren<T>(children: Children, callback: MapCallback<T>): T[];
+export declare function eachChildren(children: Children, callback: MapCallback<void>): void;
+export declare function toggleArray(arr: any[] | null | undefined, value: any): any[];
+export declare function getTextByChildren(children: Children): string;
+export declare function isEmptyString(o: any): boolean;
+export declare function isEmptyChildren(o: Children): boolean;
+export declare function isComponentVNode<T extends ComponentConstructor>(o: any, tag: T): o is VNodeComponentClass<T extends ComponentConstructor<infer P> ? P : never>;
+export declare function range(start: number, end: number): number[];
+export declare function strPad(str: number | string, length: number, pad?: string): string;
+declare type EqualArrayValue = any | EqualArrayValue[];
+export declare function isEqualArray(a: EqualArrayValue, b: EqualArrayValue): boolean;
+export declare function last<T>(arr: T[]): T | undefined;
+export declare const expandAnimationCallbacks: {
+    name: string;
+    onLeave: (el: HTMLElement) => void;
+    onAfterLeave: (el: HTMLElement) => void;
+    onBeforeEnter: (el: HTMLElement) => void;
+    onEnter: (el: HTMLElement) => void;
+    onAfterEnter: (el: HTMLElement) => void;
+};
+export declare function throttle<T>(fn: (arg: T) => void, time: number, doAlways?: (arg: T) => void): (arg: T) => void;
+export declare function debounce(fn: Function, time: number, immediately?: boolean): () => any;
+export declare function nextFrame(fn: () => void): void;
+export {};
+
+
+export {normalize} from 'intact-vue-next';

package/components/utils.js

@@ -0,0 +1,361 @@
+import _extends from "@babel/runtime-corejs3/helpers/extends";
+import _mapInstanceProperty from "@babel/runtime-corejs3/core-js/instance/map";
+import _Object$keys from "@babel/runtime-corejs3/core-js/object/keys";
+import _sliceInstanceProperty from "@babel/runtime-corejs3/core-js/instance/slice";
+import _spliceInstanceProperty from "@babel/runtime-corejs3/core-js/instance/splice";
+import _trimInstanceProperty from "@babel/runtime-corejs3/core-js/instance/trim";
+import { isText } from 'intact-vue-next';
+import { isStringOrNumber, isString, isNullOrUndefined, isInvalid } from 'intact-shared'; // @reference https://github.com/andreypopp/autobind-decorator/blob/master/src/index.js
+// for loose mode
+
+export function bind(target, key, descriptor) {
+  var method = descriptor.value; // In IE11 calling Object.defineProperty has a side-effect of evaluating the
+  // getter for the property which is being replaced. This causes infinite
+  // recursion and an "Out of stack space" error.
+
+  var definingProperty = false;
+  return {
+    configurable: true,
+    get: function get() {
+      if (definingProperty || this === target ||
+      /* get method from prototype */
+      this.hasOwnProperty('constructor')
+      /* get method from prototype, e.g. super call */
+      ) {
+        return method;
+      }
+
+      var value = method.bind(this);
+      definingProperty = true;
+      Object.defineProperty(this, key, {
+        value: value,
+        configurable: true,
+        writable: true
+      });
+      definingProperty = false;
+      return value;
+    },
+    set: function set(value) {
+      Object.defineProperty(this, key, {
+        value: value,
+        configurable: true,
+        writable: true
+      });
+    }
+  };
+} // class A {
+// @bind
+// hello() {
+// console.log('A hello', this);
+// }
+// @bind
+// test() {
+// console.log('A test', this);
+// }
+// }
+// const test1 = A.prototype.hello;
+// test1();
+// const test2 = (new A()).hello;
+// test2();
+// class B extends A {
+// @bind
+// hello() {
+// super.hello();
+// console.log('B hello', this);
+// }
+// }
+// class C extends B {
+// @bind
+// test() {
+// super.test();
+// console.log('C test', this);
+// }
+// }
+// const b = new B();
+// const c = new C();
+// const hello = b.hello;
+// const test = c.test;
+// hello();
+// test();
+
+export function addStyle(style, extra) {
+  if (!style) return extra;
+  if (!extra) return style;
+
+  if (typeof style === 'string') {
+    var _context;
+
+    var _extra = _mapInstanceProperty(_context = _Object$keys(extra)).call(_context, function (key) {
+      return kebabCase(key) + ": " + extra[key];
+    }).join(';');
+
+    style = "" + style + (!style || /;\s*$/.test(style) ? '' : ';') + _extra;
+  } else {
+    style = _extends({}, style, extra);
+  }
+
+  return style;
+}
+var _cache = {};
+var uppercasePattern = /[A-Z]/g;
+export function kebabCase(word) {
+  if (!_cache[word]) {
+    _cache[word] = word.replace(uppercasePattern, function (item) {
+      return "-" + item.toLowerCase();
+    });
+  }
+
+  return _cache[word];
+}
+export function isTextChildren(o) {
+  if (isStringOrNumber(o)) return true;
+
+  if (Array.isArray(o)) {
+    return o.every(function (item) {
+      return isTextChildren(item);
+    });
+  }
+
+  return isTextVNode(o);
+}
+export function isTextVNode(o) {
+  return o && isText(o);
+} // for detect if it is a text node in Angular
+
+export function isTextBlock(o) {
+  return isTextChildren(o) || o && o.tag && o.tag.$id === 'AngularBlockWrapper' && o.props.isText;
+}
+export function isStringOrNumberNotEmpty(o) {
+  var type = typeof o;
+  return type === 'string' && !/^\s+$/.test(o) || type === 'number';
+}
+export function getRestProps(component, props) {
+  if (props === void 0) {
+    props = component.get();
+  }
+
+  var Ctor = component.constructor;
+  var typeDefs = Ctor.typeDefs;
+  var events = Ctor.events;
+  var ret = {};
+
+  for (var key in props) {
+    switch (key) {
+      case 'key':
+      case 'ref':
+      case 'className':
+      case 'children':
+        continue;
+
+      default:
+        if (key[0] === '$' || typeDefs && key in typeDefs || events && key.substr(3) in events || key.substr(0, 4) === 'ev-$') {
+          continue;
+        }
+
+        ret[key] = props[key];
+        break;
+    }
+  }
+
+  return ret;
+}
+var externalLinkReg = /^(https?:)?\/\//;
+export function isExternalLink(to) {
+  if (!isString(to)) return false;
+  return externalLinkReg.test(to);
+}
+export function clamp(number, lower, upper) {
+  return Math.min(Math.max(number, lower), upper);
+}
+export function stopPropagation(e) {
+  e.stopPropagation();
+}
+export function findChildren(children, callback) {
+  var found = undefined;
+  if (isInvalid(children)) return found;
+  var index = -1;
+
+  var loop = function loop(children) {
+    if (Array.isArray(children)) {
+      for (var i = 0; i < children.length; i++) {
+        var vNode = children[i];
+        if (isInvalid(vNode)) continue;
+
+        if (loop(vNode)) {
+          found = vNode;
+          break;
+        }
+      }
+    } else {
+      return callback(children, ++index);
+    }
+  };
+
+  loop(children);
+  return found;
+}
+export function mapChildren(children, callback) {
+  var results = [];
+  findChildren(children, function (vNode, index) {
+    results.push(callback(vNode, index));
+    return false;
+  });
+  return results;
+}
+export function eachChildren(children, callback) {
+  findChildren(children, function (vNode, index) {
+    callback(vNode, index);
+    return false;
+  });
+} // mapChildren(['a', null, 'b', ['c', 'd', ['e', null,  'f'], 'g'], 'h'], (a, b) => console.log(a, b));
+
+export function toggleArray(arr, value) {
+  if (!Array.isArray(arr)) {
+    return [value];
+  } else {
+    arr = _sliceInstanceProperty(arr).call(arr, 0);
+    var index = arr.indexOf(value);
+
+    if (~index) {
+      _spliceInstanceProperty(arr).call(arr, index, 1);
+    } else {
+      arr.push(value);
+    }
+
+    return arr;
+  }
+}
+export function getTextByChildren(children) {
+  var ret = '';
+  if (isInvalid(children)) return ret;
+
+  if (Array.isArray(children)) {
+    children.forEach(function (vNode) {
+      ret += getTextByChildren(vNode);
+    });
+  } else if (isStringOrNumber(children)) {
+    ret += children;
+  } else if (isTextVNode(children)) {
+    ret += children.children;
+  }
+
+  return _trimInstanceProperty(ret).call(ret);
+}
+export function isEmptyString(o) {
+  return isNullOrUndefined(o) || o === '';
+}
+export function isEmptyChildren(o) {
+  return isEmptyString(o) || Array.isArray(o) && o.every(function (item) {
+    return isEmptyChildren(item);
+  });
+}
+export function isComponentVNode(o, tag) {
+  return o.tag === tag;
+}
+export function range(start, end) {
+  var _context2;
+
+  return _mapInstanceProperty(_context2 = Array.apply(null, {
+    length: end - start + 1
+  })).call(_context2, function (v, i) {
+    return i + start;
+  });
+}
+export function strPad(str, length, pad) {
+  if (pad === void 0) {
+    pad = '0';
+  }
+
+  str = str.toString();
+  var l = str.length;
+
+  if (l < length) {
+    str = new Array(length - l + 1).join(pad) + str;
+  }
+
+  return str;
+}
+export function isEqualArray(a, b) {
+  if (a === b) return true;
+
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every(function (value, index) {
+      return isEqualArray(value, b[index]);
+    });
+  }
+
+  return false;
+}
+export function last(arr) {
+  return arr[arr.length - 1];
+}
+export var expandAnimationCallbacks = {
+  'name': 'k-expand',
+  'onLeave': function onLeave(el) {
+    var height = el.clientHeight;
+    el.style.height = height + "px";
+    nextFrame(function () {
+      el.style.height = "0px";
+    });
+  },
+  'onAfterLeave': function onAfterLeave(el) {
+    el.style.height = '';
+  },
+  'onBeforeEnter': function onBeforeEnter(el) {
+    // we should set the enter el's height to 0
+    // otherwise it will affect the movable el's position 
+    el.style.height = "0px";
+  },
+  'onEnter': function onEnter(el) {
+    el.style.height = '';
+    var height = el.clientHeight;
+    el.style.height = "0px";
+    nextFrame(function () {
+      el.style.height = height + "px";
+    });
+  },
+  'onAfterEnter': function onAfterEnter(el) {
+    el.style.height = '';
+  }
+};
+export function throttle(fn, time, doAlways) {
+  var lock = false;
+  var timer;
+  return function (arg) {
+    if (doAlways) doAlways(arg);
+    if (lock) return;
+    lock = true;
+    timer = window.setTimeout(function () {
+      fn(arg);
+      lock = false;
+    }, time);
+  };
+}
+export function debounce(fn, time, immediately) {
+  if (immediately === void 0) {
+    immediately = false;
+  }
+
+  var timer;
+  var lock = !immediately;
+  return function () {
+    if (!lock) {
+      lock = true;
+      return fn();
+    }
+
+    window.clearTimeout(timer);
+    timer = window.setTimeout(function () {
+      fn();
+      lock = !immediately;
+    }, time);
+  };
+}
+export function nextFrame(fn) {
+  requestAnimationFrame(function () {
+    requestAnimationFrame(fn);
+  });
+}
+
+export {normalize} from 'intact-vue-next';

package/hooks/useDelayClose.d.ts

@@ -0,0 +1,7 @@
+export declare function useDelayClose(close: () => void, duration: number): {
+    onMouseEnter: (e: MouseEvent) => void;
+    onMouseLeave: (e: MouseEvent) => void;
+};
+
+
+export {normalize} from 'intact-vue-next';

package/hooks/useDelayClose.js

@@ -0,0 +1,37 @@
+import { onMounted, useInstance, onUnmounted } from 'intact-vue-next';
+export function useDelayClose(close, duration) {
+  var instance = useInstance();
+  var timer;
+
+  function delayClose() {
+    if (duration) {
+      timer = window.setTimeout(close, duration);
+    }
+  }
+
+  function onMouseEnter(e) {
+    instance.trigger('mouseenter', e);
+    clearTimeout(timer);
+  }
+
+  function onMouseLeave(e) {
+    instance.trigger('mouseleave', e); // mouse leave event is not a delegated event,
+    // and it will not unmount when the dom has unmounted,
+    // so we must detect the $unmounted status here
+
+    if (instance.$unmounted) return;
+    clearTimeout(timer);
+    delayClose();
+  }
+
+  onMounted(delayClose);
+  onUnmounted(function () {
+    clearTimeout(timer);
+  });
+  return {
+    onMouseEnter: onMouseEnter,
+    onMouseLeave: onMouseLeave
+  };
+}
+
+export {normalize} from 'intact-vue-next';

package/hooks/useDocumentClick.d.ts

@@ -0,0 +1,9 @@
+import { RefObject } from 'intact-vue-next';
+export interface IgnoreClickEvent extends MouseEvent {
+    _ignore?: boolean;
+}
+export declare function useDocumentClick(ref: RefObject<Element> | (() => Element), callback: (e: MouseEvent) => void, manual?: boolean): (() => void)[];
+export declare function containsOrEqual(elem: Element, target: Element): boolean;
+
+
+export {normalize} from 'intact-vue-next';

package/hooks/useDocumentClick.js

@@ -0,0 +1,37 @@
+import { onMounted, onUnmounted } from 'intact-vue-next';
+import { isFunction } from 'intact-shared';
+export function useDocumentClick(ref, callback, manual) {
+  if (manual === void 0) {
+    manual = false;
+  }
+
+  var onDocumentClick = function onDocumentClick(e) {
+    if (e._ignore) return;
+    var target = e.target;
+    var elem = isFunction(ref) ? ref() : ref.value;
+    if (containsOrEqual(elem, target)) return;
+    callback(e);
+  };
+
+  var add = function add() {
+    document.addEventListener('click', onDocumentClick);
+    document.addEventListener('contextmenu', onDocumentClick);
+  };
+
+  var remove = function remove() {
+    document.removeEventListener('click', onDocumentClick);
+    document.removeEventListener('contextmenu', onDocumentClick);
+  };
+
+  if (!manual) {
+    onMounted(add);
+  }
+
+  onUnmounted(remove);
+  return [add, remove];
+}
+export function containsOrEqual(elem, target) {
+  return target === elem || elem.contains(target);
+}
+
+export {normalize} from 'intact-vue-next';

package/hooks/useDraggable.d.ts

@@ -0,0 +1,12 @@
+export declare type Options = {
+    onStart?: (e: MouseEvent) => void;
+    onMove: (e: MouseEvent) => void;
+    onEnd?: (e?: MouseEvent) => void;
+};
+export declare function useDraggable(options: Options): {
+    start: (e: MouseEvent) => void;
+    dragging: import("./useState").State<boolean>;
+};
+
+
+export {normalize} from 'intact-vue-next';