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

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

@@ -0,0 +1,294 @@
+import { getCurrentInstance, watch, onMounted, onUpdated, onBeforeUnmount, isVNode, cloneVNode, callWithAsyncErrorHandling } from 'vue';
+import { getComponentName, queuePostFlushCb } from './scheduler.mjs';
+
+"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 = 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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,169 @@
+import { callWithErrorHandling } from '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;
+        }
+        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 };

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

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

package/es/common/no-data/no-data.d.ts

@@ -0,0 +1,16 @@
+import './no-data.scss';
+export declare const IBizNoData: import("vue").DefineComponent<{
+    text: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {
+    ns: import("@ibiz-template/core").Namespace;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    text: {
+        type: StringConstructor;
+        default: string;
+    };
+}>>, {
+    text: string;
+}, {}>;

package/es/common/no-data/no-data.mjs

@@ -0,0 +1,33 @@
+import { resolveComponent, createVNode, defineComponent } from 'vue';
+import { useNamespace } from '@ibiz-template/vue3-util';
+import './no-data.css';
+
+"use strict";
+const IBizNoData = /* @__PURE__ */ defineComponent({
+  name: "IBizNoData",
+  props: {
+    text: {
+      type: String,
+      default: "\u6682\u65E0\u6570\u636E"
+    }
+  },
+  setup() {
+    const ns = useNamespace("no-data");
+    return {
+      ns
+    };
+  },
+  render() {
+    return createVNode(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)];
+      }
+    });
+  }
+});
+
+export { IBizNoData };

package/es/common/rawitem/rawitem.css

@@ -0,0 +1 @@
+.ibiz-rawitem{width:100%;height:100%;font-size:var(--ibiz-font-size-regular);color:var(--ibiz-editor-default-text-color)}.ibiz-rawitem .ibiz-icon{width:100%;height:100%}

package/es/common/rawitem/rawitem.d.ts

@@ -0,0 +1,51 @@
+import { PropType, Ref } from 'vue';
+import { IRawItemContainer } from '@ibiz/model-core';
+import './rawitem.scss';
+export declare const IBizRawItem: import("vue").DefineComponent<{
+    type: {
+        type: StringConstructor;
+        required: false;
+    };
+    content: {
+        type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
+    };
+    rawItem: {
+        type: PropType<IRawItemContainer>;
+        required: false;
+    };
+}, {
+    ns: import("@ibiz-template/core").Namespace;
+    rawItemText: Ref<string | number | IData>;
+    playerParams: Ref<{
+        id: string;
+        path: string;
+        mute: boolean;
+        autoplay: boolean;
+        replay: boolean;
+        showcontrols: boolean;
+    }>;
+    dividerParams: Ref<{
+        contentPosition: string;
+        html: string;
+    }>;
+    alertParams: Ref<{
+        type: string;
+        title: string;
+        closeabled: boolean;
+        showIcon: boolean;
+    }>;
+    rawItemType: Ref<string>;
+    rawItemContent: Ref<string | number | IData>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    type: {
+        type: StringConstructor;
+        required: false;
+    };
+    content: {
+        type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
+    };
+    rawItem: {
+        type: PropType<IRawItemContainer>;
+        required: false;
+    };
+}>>, {}, {}>;