@ibiz-template/vue3-components 0.1.2 → 0.1.3

package/es/common/keep-alive/keep-alive.mjs

@@ -1,293 +0,0 @@
-import { getCurrentInstance, watch, onMounted, onUpdated, onBeforeUnmount, isVNode, cloneVNode, callWithAsyncErrorHandling } from 'vue';
-import { getComponentName, queuePostFlushCb } from './scheduler.mjs';
-
-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 = 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 = 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);
-    }
-    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));
-      }
-    };
-    onMounted(cacheSubtree);
-    onUpdated(cacheSubtree);
-    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 (!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 = 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 = 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 = queuePostFlushCb;
-function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
-  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);
-  }
-}
-
-export { IBizKeepAlive, MoveType, ShapeFlags, devtoolsComponentAdded, invokeArrayFns, invokeVNodeHook, isAsyncWrapper, isKeepAlive, queuePostRenderEffect, setTransitionHooks };

package/es/common/keep-alive/scheduler.d.ts

@@ -1,41 +0,0 @@
-import { ComponentInternalInstance, ConcreteComponent } from 'vue';
-export declare const NOOP: () => void;
-export interface SchedulerJob extends Function {
-    id?: number;
-    pre?: boolean;
-    active?: boolean;
-    computed?: boolean;
-    /**
-     * Indicates whether the effect is allowed to recursively trigger itself
-     * when managed by the scheduler.
-     *
-     * By default, a job cannot trigger itself because some built-in method calls,
-     * e.g. Array.prototype.push actually performs reads as well (#1740) which
-     * can lead to confusing infinite loops.
-     * The allowed cases are component update functions and watch callbacks.
-     * Component update functions may update child component props, which in turn
-     * trigger flush: "pre" watch callbacks that mutates state that the parent
-     * relies on (#1801). Watch callbacks doesn't track its dependencies so if it
-     * triggers itself again, it's likely intentional and it is the user's
-     * responsibility to perform recursive state mutation that eventually
-     * stabilizes (#1727).
-     */
-    allowRecurse?: boolean;
-    /**
-     * Attached by renderer.ts when setting up a component's render effect
-     * Used to obtain component information when reporting max recursive updates.
-     * dev only.
-     */
-    ownerInstance?: ComponentInternalInstance;
-}
-export type SchedulerJobs = SchedulerJob | SchedulerJob[];
-type CountMap = Map<SchedulerJob, number>;
-export declare function nextTick<T = void>(this: T, fn?: () => void): Promise<void>;
-export declare function queueJob(job: SchedulerJob): void;
-export declare function invalidateJob(job: SchedulerJob): void;
-export declare function queuePostFlushCb(cb: SchedulerJobs): void;
-export declare function flushPreFlushCbs(seen?: CountMap, i?: number): void;
-export declare function flushPostFlushCbs(seen?: CountMap): void;
-export declare const isFunction: (val: unknown) => val is Function;
-export declare const getComponentName: (Component: ConcreteComponent, includeInferred?: boolean) => string | false | undefined;
-export {};

package/es/common/keep-alive/scheduler.mjs

@@ -1,168 +0,0 @@
-import { callWithErrorHandling } from 'vue';
-
-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;
-        }
-        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);
-  }
-}
-
-export { NOOP, flushPostFlushCbs, flushPreFlushCbs, getComponentName, invalidateJob, isFunction, nextTick, queueJob, queuePostFlushCb };