@ibiz-template/mob-vue3-components 0.0.1-alpha.19

package/lib/common/keep-alive/keep-alive.cjs

@@ -0,0 +1,305 @@
+'use strict';
+
+var vue = require('vue');
+var scheduler = require('./scheduler.cjs');
+
+"use strict";
+const __DEV__ = true;
+var ShapeFlags = /* @__PURE__ */ ((ShapeFlags2) => {
+  ShapeFlags2[ShapeFlags2["ELEMENT"] = 1] = "ELEMENT";
+  ShapeFlags2[ShapeFlags2["FUNCTIONAL_COMPONENT"] = 2] = "FUNCTIONAL_COMPONENT";
+  ShapeFlags2[ShapeFlags2["STATEFUL_COMPONENT"] = 4] = "STATEFUL_COMPONENT";
+  ShapeFlags2[ShapeFlags2["TEXT_CHILDREN"] = 8] = "TEXT_CHILDREN";
+  ShapeFlags2[ShapeFlags2["ARRAY_CHILDREN"] = 16] = "ARRAY_CHILDREN";
+  ShapeFlags2[ShapeFlags2["SLOTS_CHILDREN"] = 32] = "SLOTS_CHILDREN";
+  ShapeFlags2[ShapeFlags2["TELEPORT"] = 64] = "TELEPORT";
+  ShapeFlags2[ShapeFlags2["SUSPENSE"] = 128] = "SUSPENSE";
+  ShapeFlags2[ShapeFlags2["COMPONENT_SHOULD_KEEP_ALIVE"] = 256] = "COMPONENT_SHOULD_KEEP_ALIVE";
+  ShapeFlags2[ShapeFlags2["COMPONENT_KEPT_ALIVE"] = 512] = "COMPONENT_KEPT_ALIVE";
+  ShapeFlags2[ShapeFlags2["COMPONENT"] = 6] = "COMPONENT";
+  return ShapeFlags2;
+})(ShapeFlags || {});
+var MoveType = /* @__PURE__ */ ((MoveType2) => {
+  MoveType2[MoveType2["ENTER"] = 0] = "ENTER";
+  MoveType2[MoveType2["LEAVE"] = 1] = "LEAVE";
+  MoveType2[MoveType2["REORDER"] = 2] = "REORDER";
+  return MoveType2;
+})(MoveType || {});
+const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
+const KeepAliveImpl = {
+  name: `IBizKeepAlive`,
+  // Marker for special handling inside the renderer. We are not using a ===
+  // check directly on KeepAlive in the renderer, because importing it directly
+  // would prevent it from being tree-shaken.
+  __isKeepAlive: true,
+  props: {
+    include: [String, RegExp, Array],
+    exclude: [String, RegExp, Array],
+    max: [String, Number],
+    keyList: [Array]
+  },
+  setup(props, { slots }) {
+    const instance = vue.getCurrentInstance();
+    const sharedContext = instance.ctx;
+    const cache = /* @__PURE__ */ new Map();
+    const keys = /* @__PURE__ */ new Set();
+    let current = null;
+    if (__DEV__) {
+      instance.__v_cache = cache;
+    }
+    const parentSuspense = instance.suspense;
+    const {
+      renderer: {
+        p: patch,
+        m: move,
+        um: _unmount,
+        o: { createElement }
+      }
+    } = sharedContext;
+    const storageContainer = createElement("div");
+    sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => {
+      const instance2 = vnode.component;
+      move(vnode, container, anchor, 0 /* ENTER */, parentSuspense);
+      patch(
+        instance2.vnode,
+        vnode,
+        container,
+        anchor,
+        instance2,
+        parentSuspense,
+        isSVG,
+        vnode.slotScopeIds,
+        optimized
+      );
+      queuePostRenderEffect(() => {
+        instance2.isDeactivated = false;
+        if (instance2.a) {
+          invokeArrayFns(instance2.a);
+        }
+        const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
+        if (vnodeHook) {
+          invokeVNodeHook(vnodeHook, instance2.parent, vnode);
+        }
+      });
+      if (__DEV__) {
+        devtoolsComponentAdded(instance2);
+      }
+    };
+    sharedContext.deactivate = (vnode) => {
+      const instance2 = vnode.component;
+      move(vnode, storageContainer, null, 1 /* LEAVE */, parentSuspense);
+      queuePostRenderEffect(() => {
+        if (instance2.da) {
+          invokeArrayFns(instance2.da);
+        }
+        const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
+        if (vnodeHook) {
+          invokeVNodeHook(vnodeHook, instance2.parent, vnode);
+        }
+        instance2.isDeactivated = true;
+      });
+      if (__DEV__) {
+        devtoolsComponentAdded(instance2);
+      }
+    };
+    function unmount(vnode) {
+      resetShapeFlag(vnode);
+      _unmount(vnode, instance, parentSuspense, true);
+    }
+    function pruneCache(filter) {
+      cache.forEach((vnode, key) => {
+        const name = scheduler.getComponentName(vnode.type);
+        if (name && (!filter || !filter(name))) {
+          pruneCacheEntry(key);
+        }
+      });
+    }
+    function pruneCache2(filter) {
+      cache.forEach((vnode, key) => {
+        const name = vnode.key;
+        if (name && (filter && filter(name))) {
+          pruneCacheEntry(key);
+        }
+      });
+    }
+    function pruneCacheEntry(key) {
+      const cached = cache.get(key);
+      if (!current || cached.type !== current.type) {
+        unmount(cached);
+      } else if (current) {
+        resetShapeFlag(current);
+      }
+      cache.delete(key);
+      keys.delete(key);
+    }
+    vue.watch(
+      () => [props.include, props.exclude, props.keyList],
+      ([include, exclude, keyList]) => {
+        include && pruneCache((name) => matches(include, name));
+        exclude && pruneCache((name) => !matches(exclude, name));
+        keyList && pruneCache2((name) => !matches(keyList, name));
+      },
+      // prune post-render after `current` has been updated
+      { flush: "post", deep: true }
+    );
+    let pendingCacheKey = null;
+    const cacheSubtree = () => {
+      if (pendingCacheKey != null) {
+        cache.set(pendingCacheKey, getInnerChild(instance.subTree));
+      }
+    };
+    vue.onMounted(cacheSubtree);
+    vue.onUpdated(cacheSubtree);
+    vue.onBeforeUnmount(() => {
+      for (const key in cache) {
+        pruneCacheEntry(key);
+      }
+    });
+    return () => {
+      pendingCacheKey = null;
+      if (!slots.default) {
+        return null;
+      }
+      const children = slots.default();
+      const rawVNode = children[0];
+      if (children.length > 1) {
+        console.log(`KeepAlive should contain exactly one component child.`);
+        current = null;
+        return children;
+      }
+      if (!vue.isVNode(rawVNode) || !(rawVNode.shapeFlag & 4 /* STATEFUL_COMPONENT */) && !(rawVNode.shapeFlag & 128 /* SUSPENSE */)) {
+        current = null;
+        return rawVNode;
+      }
+      let vnode = getInnerChild(rawVNode);
+      const comp = vnode.type;
+      const name = scheduler.getComponentName(
+        isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp
+      );
+      const { include, exclude, max, keyList } = props;
+      const slotKey = vnode.key;
+      if (
+        // 包括并且不匹配的
+        include && (!name || !matches(include, name)) || // 排除并且匹配的
+        exclude && name && matches(exclude, name) || // keyList中存在并且不匹配的
+        keyList && !slotKey && !matches(keyList, slotKey)
+      ) {
+        current = vnode;
+        return rawVNode;
+      }
+      const key = vnode.key == null ? comp : vnode.key;
+      const cachedVNode = cache.get(key);
+      if (vnode.el) {
+        vnode = vue.cloneVNode(vnode);
+        if (rawVNode.shapeFlag & 128 /* SUSPENSE */) {
+          rawVNode.ssContent = vnode;
+        }
+      }
+      pendingCacheKey = key;
+      if (cachedVNode) {
+        vnode.el = cachedVNode.el;
+        vnode.component = cachedVNode.component;
+        if (vnode.transition) {
+          setTransitionHooks(vnode, vnode.transition);
+        }
+        vnode.shapeFlag |= 512 /* COMPONENT_KEPT_ALIVE */;
+        keys.delete(key);
+        keys.add(key);
+      } else {
+        keys.add(key);
+        if (max && keys.size > parseInt(max, 10)) {
+          pruneCacheEntry(keys.values().next().value);
+        }
+      }
+      vnode.shapeFlag |= 256 /* COMPONENT_SHOULD_KEEP_ALIVE */;
+      current = vnode;
+      vnode.keepAlive = true;
+      vnode.curPath = slotKey;
+      return vnode;
+    };
+  }
+};
+const IBizKeepAlive = KeepAliveImpl;
+function matches(pattern, name) {
+  if (Array.isArray(pattern)) {
+    return pattern.indexOf(name) > -1;
+  }
+  if (typeof pattern === "string") {
+    return pattern.split(",").includes(name);
+  }
+  if (isRegExp(pattern)) {
+    return pattern.test(name);
+  }
+  return false;
+}
+function resetShapeFlag(vnode) {
+  vnode.shapeFlag &= ~256 /* COMPONENT_SHOULD_KEEP_ALIVE */;
+  vnode.shapeFlag &= ~512 /* COMPONENT_KEPT_ALIVE */;
+}
+function getInnerChild(vnode) {
+  return vnode.shapeFlag & 128 /* SUSPENSE */ ? vnode.ssContent : vnode;
+}
+function isRegExp(v) {
+  return Object.prototype.toString.call(v) === "[object RegExp]";
+}
+const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
+function setTransitionHooks(vnode, hooks) {
+  if (vnode.shapeFlag & 6 /* COMPONENT */ && vnode.component) {
+    setTransitionHooks(vnode.component.subTree, hooks);
+  } else {
+    vnode.transition = hooks;
+  }
+}
+const invokeArrayFns = (fns, arg) => {
+  for (let i = 0; i < fns.length; i++) {
+    fns[i](arg);
+  }
+};
+const queuePostRenderEffect = scheduler.queuePostFlushCb;
+function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
+  vue.callWithAsyncErrorHandling(hook, instance, 7, [
+    vnode,
+    prevVNode
+  ]);
+}
+var DevtoolsHooks = /* @__PURE__ */ ((DevtoolsHooks2) => {
+  DevtoolsHooks2["APP_INIT"] = "app:init";
+  DevtoolsHooks2["APP_UNMOUNT"] = "app:unmount";
+  DevtoolsHooks2["COMPONENT_UPDATED"] = "component:updated";
+  DevtoolsHooks2["COMPONENT_ADDED"] = "component:added";
+  DevtoolsHooks2["COMPONENT_REMOVED"] = "component:removed";
+  DevtoolsHooks2["COMPONENT_EMIT"] = "component:emit";
+  DevtoolsHooks2["PERFORMANCE_START"] = "perf:start";
+  DevtoolsHooks2["PERFORMANCE_END"] = "perf:end";
+  return DevtoolsHooks2;
+})(DevtoolsHooks || {});
+const devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook(
+  "component:added" /* COMPONENT_ADDED */
+);
+function createDevtoolsComponentHook(hook) {
+  return (component) => {
+    emit(
+      hook,
+      component.appContext.app,
+      component.uid,
+      component.parent ? component.parent.uid : void 0,
+      component
+    );
+  };
+}
+function emit(event, ...args) {
+  if (window.__VUE_DEVTOOLS_GLOBAL_HOOK__) {
+    window.__VUE_DEVTOOLS_GLOBAL_HOOK__.emit(event, ...args);
+  }
+}
+
+exports.IBizKeepAlive = IBizKeepAlive;
+exports.MoveType = MoveType;
+exports.ShapeFlags = ShapeFlags;
+exports.devtoolsComponentAdded = devtoolsComponentAdded;
+exports.invokeArrayFns = invokeArrayFns;
+exports.invokeVNodeHook = invokeVNodeHook;
+exports.isAsyncWrapper = isAsyncWrapper;
+exports.isKeepAlive = isKeepAlive;
+exports.queuePostRenderEffect = queuePostRenderEffect;
+exports.setTransitionHooks = setTransitionHooks;

package/lib/common/keep-alive/scheduler.cjs

@@ -0,0 +1,179 @@
+'use strict';
+
+var vue = require('vue');
+
+"use strict";
+const __DEV__ = true;
+const NOOP = () => {
+};
+let isFlushing = false;
+let isFlushPending = false;
+const queue = [];
+let flushIndex = 0;
+const pendingPostFlushCbs = [];
+let activePostFlushCbs = null;
+let postFlushIndex = 0;
+const resolvedPromise = /* @__PURE__ */ Promise.resolve();
+let currentFlushPromise = null;
+const RECURSION_LIMIT = 100;
+function nextTick(fn) {
+  const p = currentFlushPromise || resolvedPromise;
+  return fn ? p.then(this ? fn.bind(this) : fn) : p;
+}
+function findInsertionIndex(id) {
+  let start = flushIndex + 1;
+  let end = queue.length;
+  while (start < end) {
+    const middle = start + end >>> 1;
+    const middleJobId = getId(queue[middle]);
+    middleJobId < id ? start = middle + 1 : end = middle;
+  }
+  return start;
+}
+function queueJob(job) {
+  if (!queue.length || !queue.includes(
+    job,
+    isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex
+  )) {
+    if (job.id == null) {
+      queue.push(job);
+    } else {
+      queue.splice(findInsertionIndex(job.id), 0, job);
+    }
+    queueFlush();
+  }
+}
+function queueFlush() {
+  if (!isFlushing && !isFlushPending) {
+    isFlushPending = true;
+    currentFlushPromise = resolvedPromise.then(flushJobs);
+  }
+}
+function invalidateJob(job) {
+  const i = queue.indexOf(job);
+  if (i > flushIndex) {
+    queue.splice(i, 1);
+  }
+}
+function queuePostFlushCb(cb) {
+  if (!Array.isArray(cb)) {
+    if (!activePostFlushCbs || !activePostFlushCbs.includes(
+      cb,
+      cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex
+    )) {
+      pendingPostFlushCbs.push(cb);
+    }
+  } else {
+    pendingPostFlushCbs.push(...cb);
+  }
+  queueFlush();
+}
+function flushPreFlushCbs(seen, i = isFlushing ? flushIndex + 1 : 0) {
+  if (__DEV__) {
+    seen = seen || /* @__PURE__ */ new Map();
+  }
+  for (; i < queue.length; i++) {
+    const cb = queue[i];
+    if (cb && cb.pre) {
+      if (__DEV__ && checkRecursiveUpdates(seen, cb)) {
+        continue;
+      }
+      queue.splice(i, 1);
+      i--;
+      cb();
+    }
+  }
+}
+function flushPostFlushCbs(seen) {
+  if (pendingPostFlushCbs.length) {
+    const deduped = [...new Set(pendingPostFlushCbs)];
+    pendingPostFlushCbs.length = 0;
+    if (activePostFlushCbs) {
+      activePostFlushCbs.push(...deduped);
+      return;
+    }
+    activePostFlushCbs = deduped;
+    if (__DEV__) {
+      seen = seen || /* @__PURE__ */ new Map();
+    }
+    activePostFlushCbs.sort((a, b) => getId(a) - getId(b));
+    for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
+      if (__DEV__ && checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) {
+        continue;
+      }
+      activePostFlushCbs[postFlushIndex]();
+    }
+    activePostFlushCbs = null;
+    postFlushIndex = 0;
+  }
+}
+const getId = (job) => job.id == null ? Infinity : job.id;
+const comparator = (a, b) => {
+  const diff = getId(a) - getId(b);
+  if (diff === 0) {
+    if (a.pre && !b.pre)
+      return -1;
+    if (b.pre && !a.pre)
+      return 1;
+  }
+  return diff;
+};
+function flushJobs(seen) {
+  isFlushPending = false;
+  isFlushing = true;
+  if (__DEV__) {
+    seen = seen || /* @__PURE__ */ new Map();
+  }
+  queue.sort(comparator);
+  const check = __DEV__ ? (job) => checkRecursiveUpdates(seen, job) : NOOP;
+  try {
+    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
+      const job = queue[flushIndex];
+      if (job && job.active !== false) {
+        if (__DEV__ && check(job)) {
+          continue;
+        }
+        vue.callWithErrorHandling(job, null, 14);
+      }
+    }
+  } finally {
+    flushIndex = 0;
+    queue.length = 0;
+    flushPostFlushCbs(seen);
+    isFlushing = false;
+    currentFlushPromise = null;
+    if (queue.length || pendingPostFlushCbs.length) {
+      flushJobs(seen);
+    }
+  }
+}
+const isFunction = (val) => typeof val === "function";
+const getComponentName = (Component, includeInferred = true) => {
+  return isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
+};
+function checkRecursiveUpdates(seen, fn) {
+  if (!seen.has(fn)) {
+    seen.set(fn, 1);
+  } else {
+    const count = seen.get(fn);
+    if (count > RECURSION_LIMIT) {
+      const instance = fn.ownerInstance;
+      const componentName = instance && getComponentName(instance.type);
+      console.warn(
+        `Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`
+      );
+      return true;
+    }
+    seen.set(fn, count + 1);
+  }
+}
+
+exports.NOOP = NOOP;
+exports.flushPostFlushCbs = flushPostFlushCbs;
+exports.flushPreFlushCbs = flushPreFlushCbs;
+exports.getComponentName = getComponentName;
+exports.invalidateJob = invalidateJob;
+exports.isFunction = isFunction;
+exports.nextTick = nextTick;
+exports.queueJob = queueJob;
+exports.queuePostFlushCb = queuePostFlushCb;

package/lib/common/no-data/no-data.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+var vue = require('vue');
+var vue3Util = require('@ibiz-template/vue3-util');
+require('./no-data.css');
+
+"use strict";
+const IBizNoData = /* @__PURE__ */ vue.defineComponent({
+  name: "IBizNoData",
+  props: {
+    text: {
+      type: String,
+      default: "\u6682\u65E0\u6570\u636E"
+    }
+  },
+  setup() {
+    const ns = vue3Util.useNamespace("no-data");
+    return {
+      ns
+    };
+  },
+  render() {
+    return vue.createVNode(vue.resolveComponent("van-empty"), {
+      "class": this.ns.b(),
+      "description": this.text
+    }, {
+      default: () => {
+        var _a, _b;
+        return [(_b = (_a = this.$slots).default) == null ? void 0 : _b.call(_a)];
+      }
+    });
+  }
+});
+
+exports.IBizNoData = IBizNoData;

package/lib/common/no-data/no-data.css

@@ -0,0 +1 @@
+.ibiz-no-data{width:100%;height:100%}