@quicktvui/ai 1.0.6 → 1.0.8

package/rules/.source/quicktvui/src/qtListen/types.ts

@@ -0,0 +1,311 @@
+import { isObject, isArray } from "@vue/shared";
+
+export class QtChangeData {
+  datas: Map<any, any> = new Map();
+  names: Map<any, Set<any>> = new Map();
+  dataArr?: any[]; //concat 拼接数据时使用
+  updateCount: number = 0;
+  rootUpdateCount: number = 0;
+  deth: number = -1; //深度
+  constructor(
+    public start: number,
+    public end: number,
+    public deleteCount: number = -1,
+  ) {}
+  resetData() {
+    // this.datas.clear()
+    this.start = -1;
+    this.end = -1;
+    this.deleteCount = -1;
+    if (this.datas.size) {
+      this.datas = new Map();
+    }
+  }
+}
+
+export const typeEnum = {
+  set: "set",
+  qtSet: "__qt_set",
+  push: "push",
+  splice: "splice",
+  pop: "pop",
+  concat: "concat",
+  unknownSet: "__qt_unknownSet",
+  currentType: "__qt_currentType",
+  expectCangeNum: "__qt_expectCangeNum",
+  isInit: "__qt_is_init",
+  shift: "shift",
+  unshift: "unshift",
+  newDatas: "__qt_new_datas",
+  arrChangeProp: "__qt_splice_change_prop",
+};
+
+/**
+ * 指定层级，获取按层级去重后的数据，子集被多次修改时，如果只关系父级的变化则需要按层级去重
+ */
+export const qtFilterChangeMap = (deth = 1, datas: Map<any, any>) => {
+  const res = new Map();
+  datas.forEach((dv, dk) => {
+    let rk = dk;
+    if (Array.isArray(dk) && deth > 0) {
+      rk = dk.slice(0, deth).join();
+    }
+    res.set(rk, dv);
+  });
+  return res;
+};
+
+/**
+ * 最长递增序列拆分
+ */
+export const qtLongestSequenceSplit = (maps: QtChangeData) => {
+  const changes: Map<any, QtChangeData> = new Map();
+  let _preStart = -1;
+  maps.datas.forEach((mdv, mdi) => {
+    const _start = Array.isArray(mdi) ? Number(mdi[0]) : Number(mdi);
+    let changeVal = changes.get(_preStart);
+    if (changeVal && _start >= changeVal.start && _start <= changeVal.end + 1) {
+      changeVal.updateCount++;
+      if (_start != changeVal.end) {
+        changeVal.rootUpdateCount++;
+      }
+      changeVal.end = _start;
+      changeVal.datas.set(mdi, mdv);
+    } else {
+      const start = _start;
+      const count = 1;
+      const end = start; // + count
+      changeVal = new QtChangeData(start, end);
+      changeVal.updateCount = count;
+      changeVal.rootUpdateCount = count;
+      changeVal.datas.set(mdi, mdv);
+      changeVal.deth = maps.deth;
+      _preStart = _start;
+      changes.set(_preStart, changeVal);
+    }
+    if (maps.names.get(mdi)) {
+      changeVal.names.set(mdi, maps.names.get(mdi) as Set<any>);
+    }
+  });
+  return changes;
+};
+
+interface IparseChildUpdateRef {
+  isArr: boolean;
+  arrDeeps: number[];
+  oldData: any;
+  newData: any;
+  ouData: any;
+  k: any;
+}
+/**
+ * 解析子列表更新层级
+ */
+export const parseChildUpdate = (
+  changeData: QtChangeData,
+  orData: any,
+  exFn: (res: IparseChildUpdateRef) => void,
+) => {
+  const maps = changeData.names.size ? changeData.names : changeData.datas;
+  maps.forEach((v, k) => {
+    let orUdata: any;
+    let newUdata: any;
+    const cvalue = changeData.datas.get(k);
+    const res: IparseChildUpdateRef = {
+      isArr: false,
+      arrDeeps: [],
+      ouData: cvalue,
+      newData: null,
+      oldData: null,
+      k,
+    };
+    if (Array.isArray(k)) {
+      for (let kindex = 0; kindex < k.length; kindex++) {
+        const kitem = k[kindex];
+        if (!isNaN(Number(kitem))) {
+          res.arrDeeps.push(Number(kitem));
+        }
+        if (res.arrDeeps.length > 3) {
+          break;
+        } else {
+          orUdata = orUdata ? orUdata[kitem] : orData[kitem];
+          if (kindex > 0) {
+            newUdata = newUdata ? newUdata[kitem] : cvalue[kitem];
+          } else {
+            newUdata = cvalue;
+          }
+        }
+      }
+      if (changeData.names.size && changeData.names.get(k)?.size == 1) {
+        const namev = changeData.names.get(k)?.values().next().value;
+        if (
+          isObject(orUdata) &&
+          isObject(newUdata) &&
+          isArray(orUdata[namev]) &&
+          isArray(newUdata[namev])
+        ) {
+          orUdata = orUdata[namev];
+          newUdata = newUdata[namev];
+        }
+      }
+      res.oldData = orUdata;
+      res.newData = newUdata;
+    } else {
+      res.oldData = orData[k];
+      res.newData = v;
+    }
+    res.isArr = Array.isArray(newUdata);
+    exFn(res);
+  });
+};
+
+class QtType {
+  private targetFlags: WeakMap<any, Map<string, any>> = new WeakMap();
+  private targetMaps: WeakMap<any, Map<any, QtChangeData>> = new WeakMap();
+  // private targetMapMultiple:WeakMap<any,Map<any, Map<any,QtChangeData>>> = new WeakMap()
+
+  getFlag(target: any) {
+    let flag = this.targetFlags.get(target);
+    if (!flag) {
+      this.targetFlags.set(target, (flag = new Map()));
+    }
+    return flag;
+  }
+  getTargetType(target: any, type: any) {
+    return this.getType(target)?.get(type);
+  }
+  getType(target: any) {
+    return this.targetMaps.get(target);
+  }
+  setType(target: any, type: string, datas: QtChangeData) {
+    let targetMap = this.targetMaps.get(target);
+    if (!targetMap) {
+      this.targetMaps.set(target, (targetMap = new Map()));
+    }
+    targetMap.set(type, datas);
+
+    this.getFlag(target).set(typeEnum.currentType, type);
+  }
+  deleteType(target: any, type?: string) {
+    if (typeof target !== "object") {
+      return;
+    }
+    let targetMap = this.targetMaps.get(target);
+    this.targetFlags.delete(target);
+    if (!targetMap) return;
+    if (type) {
+      targetMap.delete(type);
+    } else {
+      this.targetMaps.delete(target);
+    }
+  }
+  clear() {
+    this.targetFlags = new WeakMap();
+    this.targetMaps = new WeakMap();
+  }
+  changeTypeData(target: any, prop: any, value: any) {
+    if (this.getFlag(target).get(typeEnum.currentType) === typeEnum.pop) {
+      return false;
+    }
+    const cacheTypes = this.getType(target);
+    let isCollect = false;
+    if (cacheTypes && !isNaN(Number(prop))) {
+      cacheTypes.forEach((cacheType, key) => {
+        if (Number(prop) >= cacheType.start && Number(prop) <= cacheType.end) {
+          cacheType.datas.set(prop, value);
+          isCollect = true;
+        }
+      });
+    }
+    let eNum = this.getFlag(target).get(typeEnum.expectCangeNum);
+    if (eNum && eNum > 0) {
+      this.getFlag(target).set(typeEnum.expectCangeNum, --eNum);
+      return true;
+    }
+
+    return isCollect;
+  }
+  changeOfsetType(target: any, prop: any, value: any, name?: any, deth = 1) {
+    let cacheTypes = this.getTargetType(target, typeEnum.qtSet);
+    if (!cacheTypes) {
+      const start = (Array.isArray(prop) ? Number(prop[0]) : Number(prop)) || 0;
+      cacheTypes = new QtChangeData(start, start);
+      cacheTypes.datas.set(prop, value);
+      cacheTypes.updateCount = 1;
+      cacheTypes.rootUpdateCount = 1;
+      cacheTypes.deth = deth;
+      this.setType(target, typeEnum.qtSet, cacheTypes);
+    } else {
+      const pos = (Array.isArray(prop) ? Number(prop[0]) : Number(prop)) || 0;
+      if (!cacheTypes.datas.has(prop)) {
+        if (pos !== cacheTypes.end) {
+          cacheTypes.rootUpdateCount++;
+        }
+        cacheTypes.updateCount += 1;
+      }
+      cacheTypes.datas.set(prop, value);
+      if (pos >= cacheTypes.end) {
+        cacheTypes.end = pos;
+      } else if (pos < cacheTypes.start) {
+        cacheTypes.start = pos;
+      }
+      if (deth != cacheTypes.deth) {
+        cacheTypes.deth = -1; //如果同时修改了不通层级的数据，则无法给出固定层级
+      }
+    }
+    if (name) {
+      const names = cacheTypes.names.get(prop);
+      if (!names) {
+        cacheTypes.names.set(prop, new Set([name])); // todo: names 扁平化处理
+      } else {
+        names.add(name);
+      }
+    }
+  }
+  /**
+   * 记录splice操作数据时，具体哪些索引是真的被修改了
+   */
+  recordArrChangeProps(target: any, start: number, end: number) {
+    const flag = this.getFlag(target);
+    let changeProps: Set<any> = flag.get(typeEnum.arrChangeProp);
+    if (!changeProps) {
+      changeProps = new Set();
+      flag.set(typeEnum.arrChangeProp, changeProps);
+    }
+    if (end > start) {
+      for (let index = start; index < end; index++) {
+        changeProps.add(index);
+      }
+    }
+  }
+  /**
+   * 检测指定prop是否是由splice操作而修改的
+   * 返回true时，要么没有做splice操作，要么做了splice操作但是指定prop并不是真正被修改的索引
+   */
+  checkArrChangeProps(target: any, prop: any) {
+    const flag = this.getFlag(target);
+    const ctype = flag.get(typeEnum.currentType);
+
+    if (ctype === typeEnum.splice) {
+      let changeProps: Set<any> = flag.get(typeEnum.arrChangeProp);
+      prop = Number(prop);
+      if (!changeProps) {
+        return true;
+      } else if (!isNaN(prop) && changeProps.has(prop)) {
+        changeProps.delete(prop); //只可被识别一次，即销毁
+        return true;
+      } else {
+        return false;
+      }
+    }
+    if (ctype === typeEnum.shift) {
+      return false;
+    }
+    if (ctype === typeEnum.unshift) {
+      return false;
+    }
+    return true;
+  }
+}
+const qtType = new QtType();
+export default qtType;

package/rules/.source/quicktvui/src/qtListen/watch.ts

@@ -0,0 +1,233 @@
+import { isObject, isArray } from "@vue/shared";
+import { nextTick } from "vue"; //markRawn isReactive
+import { qtClearupTrack, QtReactiveEffect, qtTrack } from "./effect";
+import { qtDiff } from "./qtDiff";
+import { emReactiveFlags } from "./reactive"; //qtToReactive
+import qtType, {
+  qtLongestSequenceSplit,
+  typeEnum,
+  QtChangeData,
+} from "./types";
+
+export interface IQtWatchOptions {
+  init: (datas: any[]) => void;
+  add: (datas: any[]) => void;
+  update: (position: number, dataMaps: QtChangeData, oldTarget: any[]) => void; //keyPath?:Map<any,any[]>
+  insert: (position: number, datas: any[]) => void;
+  delete: (position: number, count: number) => void;
+  clear: () => void;
+  resetValue?: (datas: any[]) => void;
+  [k: string]: any;
+}
+export const qtRefUid = {
+  pointer: 0,
+  createUid(key: string = "_") {
+    this.pointer++;
+    return this.pointer + key + Date.now();
+  },
+  /**
+   * 对象添加uid
+   */
+  addUid(data: any, uk?: string) {
+    if (data !== null && typeof data === "object") {
+      if (!data.__qt_key_) {
+        data.__qt_key_ = this.createUid(uk);
+      }
+    }
+    return data;
+  },
+  /**
+   * 批量添加uid
+   */
+  addUidBatch(arr: any[], uk?: string) {
+    for (let i = 0; i < arr.length; i++) {
+      this.addUid(arr[i]);
+    }
+  },
+};
+
+export const qtCloneObj = (target: object, isKey = true) => {
+  if (isObject(target)) {
+    const res: any = isArray(target) ? [] : {};
+    for (const k in target) {
+      if (Object.prototype.hasOwnProperty.call(target, k)) {
+        const targetItem = (target as any)[k];
+        if (isObject(targetItem)) {
+          if (!isArray(targetItem)) {
+            if (!targetItem.__qt_key_) {
+              targetItem.__qt_key_ = qtRefUid.createUid(k); //标记唯一值，diff对比时使用
+            }
+            if (!targetItem.__qt_change_num_) {
+              targetItem.__qt_change_num_ = 1; //标记节点是否被修改，diff对比使用
+            }
+          }
+          res[k] = qtCloneObj(targetItem, isKey);
+        } else {
+          res[k] = targetItem;
+        }
+      }
+    }
+    return res;
+  }
+  return target;
+};
+
+// 监听器，注意必须在组件销毁时调用返回值的stop函数清除缓存依赖，防止内存泄露
+export function qtWatchAll(target: any, options: IQtWatchOptions) {
+  if (!target || !isObject(target)) return;
+  let __v_raw = target.__v_raw;
+  let oldTarget = qtCloneObj(__v_raw);
+
+  let watchNextTickFlag = false;
+  const watchNextTick = (fn: any) => {
+    if (!watchNextTickFlag) {
+      watchNextTickFlag = true;
+      nextTick(() => {
+        watchNextTickFlag = false;
+        fn();
+      });
+    }
+  };
+
+  const _effect = new QtReactiveEffect(
+    () => {
+      qtTrack(__v_raw, emReactiveFlags.WATCH_ALL);
+    },
+    (target, prop, newValue, type, oldValue) => {
+      // console.log(type,'-------',prop)
+      const _target =
+        type === emReactiveFlags.RESET_REF_VALUE ? newValue : target;
+      const _currentType = qtType.getFlag(target).get(typeEnum.currentType);
+      if (type === emReactiveFlags.RESET_REF_VALUE) {
+        options.resetValue?.(newValue);
+      }
+      if (
+        type === emReactiveFlags.RESET_REF_VALUE &&
+        !(
+          _currentType === typeEnum.concat &&
+          oldTarget &&
+          (oldTarget.length || Object.keys(newValue).length)
+        )
+      ) {
+        // if (_isInit && !((oldTarget && oldTarget.length) && _currentType === typeEnum.concat)) {
+        // 初始化数据和清空数据时，不走异步，否则页面会有闪烁或卡顿的情况
+        if (newValue && (newValue.length || Object.keys(newValue).length)) {
+          options.init(qtCloneObj(newValue, false));
+        } else {
+          options.clear();
+        }
+        __v_raw = newValue;
+
+        qtType.deleteType(oldTarget);
+        qtType.deleteType(target);
+        qtType.deleteType(__v_raw);
+        qtType.deleteType(_target);
+        qtType.clear();
+        oldTarget = qtCloneObj(__v_raw);
+      } else if (
+        !(oldTarget && (oldTarget.length || Object.keys(newValue).length)) &&
+        _target
+      ) {
+        watchNextTick(() => {
+          options.init(qtCloneObj(_target, false));
+          __v_raw = _target;
+
+          qtType.deleteType(oldTarget);
+          qtType.deleteType(target);
+          qtType.deleteType(__v_raw);
+          qtType.deleteType(_target);
+          qtType.clear();
+          oldTarget = qtCloneObj(__v_raw);
+        });
+      } else if (
+        _currentType === typeEnum.splice &&
+        !(target && (target.length || Object.keys(newValue).length))
+      ) {
+        options.clear();
+        __v_raw = target;
+
+        qtType.deleteType(oldTarget);
+        qtType.deleteType(target);
+        qtType.deleteType(__v_raw);
+        qtType.deleteType(_target);
+        qtType.clear();
+        oldTarget = qtCloneObj(__v_raw);
+      } else {
+        watchNextTick(() => {
+          const _target =
+            type === emReactiveFlags.RESET_REF_VALUE ? newValue : target;
+          const types = qtType.getType(target);
+          // console.log('--type', type, target, types?.size, '异步1',_currentType)
+          // 如果单个时间片段内只进行了一种类型的数组操作，则优先执行数组操作，否则就需要进行diff算法对比
+          if (types && types.size === 1) {
+            types.forEach((tvalue, key) => {
+              // console.log(key, '--types-',tvalue)
+              if (key === typeEnum.push || key === typeEnum.concat) {
+                options.add(
+                  tvalue.dataArr || Array.from(tvalue.datas.values()),
+                );
+              }
+              if (key === typeEnum.pop) {
+                options.delete(tvalue.start, tvalue.deleteCount);
+              }
+              if (key === typeEnum.qtSet) {
+                // console.log(tvalue,'-tvalue')
+                if (tvalue.end - tvalue.start + 1 == tvalue.rootUpdateCount) {
+                  options.update(tvalue.start, tvalue, oldTarget);
+                } else {
+                  const equence = qtLongestSequenceSplit(tvalue);
+                  equence.forEach((evalue, epos) => {
+                    // console.log(evalue,'-epos',epos)
+                    options.update(evalue.start, evalue, oldTarget);
+                  });
+                }
+              }
+              if (key === typeEnum.splice) {
+                if (tvalue.deleteCount) {
+                  options.delete(tvalue.start, tvalue.deleteCount);
+                }
+                if (tvalue.datas.size) {
+                  options.insert(
+                    tvalue.start,
+                    Array.from(tvalue.datas.values()),
+                  );
+                }
+              }
+              if (key === typeEnum.unshift) {
+                options.insert(tvalue.start, Array.from(tvalue.datas.values()));
+              }
+              if (key === typeEnum.shift) {
+                options.delete(tvalue.start, tvalue.deleteCount);
+              }
+            });
+          } else {
+            qtDiff(oldTarget, _target, options);
+          }
+
+          // if(type === emReactiveFlags.RESET_REF_VALUE){}
+          qtType.deleteType(oldTarget);
+          qtType.deleteType(target);
+          qtType.deleteType(__v_raw);
+          qtType.deleteType(_target);
+          qtType.clear();
+
+          oldTarget = qtCloneObj(__v_raw);
+        });
+      }
+
+      if (type === emReactiveFlags.RESET_REF_VALUE) {
+        qtClearupTrack(__v_raw);
+        __v_raw = newValue;
+        _effect.run();
+      }
+    },
+  );
+  _effect.run();
+  // const runner: any = _effect.run.bind(_effect)
+  return {
+    stop() {
+      qtClearupTrack(__v_raw);
+      _effect.stop();
+    },
+  };
+}

package/rules/.source/quicktvui/src/replace-child/QTIReplaceChildView.ts

@@ -0,0 +1,5 @@
+import { QTIView } from "../view/QTIView";
+
+export interface QTIReplaceChildView extends QTIView {
+  setChildSID(sid: string): void;
+}

package/rules/.source/quicktvui/src/replace-child/QTReplaceChildView.ts

@@ -0,0 +1,30 @@
+import { defineComponent, h, ref } from "vue";
+import { ESApp, Native } from "@extscreen/es3-vue";
+
+import useBaseView from "../base/useBaseView";
+
+function registerQTIReplaceChildView(app: ESApp) {
+  const ReplaceChildViewImpl = defineComponent({
+    setup(props, context) {
+      const viewRef = ref();
+
+      function setChildSID(sid: string): void {
+        Native.callUIFunction(viewRef.value, "setChildSID", [sid]);
+      }
+
+      context.expose({
+        viewRef,
+        setChildSID,
+        ...useBaseView(viewRef),
+      });
+
+      return () => {
+        const children = context.slots.default && context.slots.default();
+        return h("ReplaceChildView", { ref: viewRef }, children);
+      };
+    },
+  });
+  app.component("qt-replace-child", ReplaceChildViewImpl);
+}
+
+export default registerQTIReplaceChildView;

package/rules/.source/quicktvui/src/replace-child/QtReplaceChildViewAPI.ts

@@ -0,0 +1,37 @@
+import { isRef, Ref } from "@vue/reactivity";
+import { isString } from "../utils/type";
+import { Native } from "@extscreen/es3-vue";
+import { QT_API_MODULE, QT_CALL_UI_FUNCTION } from "../qt/QtAPIModule";
+import { QTIReplaceChildView } from "./QTIReplaceChildView";
+import { QtBaseViewAPI } from "../base/QtBaseViewAPI";
+
+export interface QtReplaceChildViewAPI extends QtBaseViewAPI {
+  setChildSID(
+    instance: string | Ref<QTIReplaceChildView | undefined>,
+    sid: string,
+  ): void;
+}
+
+export function createQtReplaceChildViewAPI(
+  viewAPI: QtBaseViewAPI,
+): QtReplaceChildViewAPI {
+  function setChildSID(
+    instance: string | Ref<QTIReplaceChildView | undefined>,
+    sid: string,
+  ): void {
+    if (isString(instance)) {
+      Native.callNative(QT_API_MODULE, QT_CALL_UI_FUNCTION, [
+        instance,
+        "setChildSID",
+        [sid],
+      ]);
+    } else if (isRef(instance) && instance.value) {
+      instance.value?.setChildSID(sid);
+    }
+  }
+
+  return {
+    ...viewAPI,
+    setChildSID,
+  };
+}

package/rules/.source/quicktvui/src/row/QTIRow.ts

@@ -0,0 +1,3 @@
+import { QTIView } from "../view/QTIView";
+
+export interface QTIRow extends QTIView {}

package/rules/.source/quicktvui/src/row/QtRowAPI.ts

@@ -0,0 +1,9 @@
+import { QtBaseViewAPI } from "../base/QtBaseViewAPI";
+
+export interface QtRowAPI extends QtBaseViewAPI {}
+
+export function createQtRowAPI(viewAPI: QtBaseViewAPI): QtRowAPI {
+  return {
+    ...viewAPI,
+  };
+}

package/rules/.source/quicktvui/src/row/index.vue

@@ -0,0 +1,29 @@
+<template>
+  <div class="qt-ui-row-css" :clipChildren="false" ref="viewRef">
+    <slot />
+  </div>
+</template>
+
+<script>
+import { defineComponent } from "@vue/runtime-core";
+import useBaseView from "../base/useBaseView";
+import { ref } from "vue";
+
+export default defineComponent({
+  name: "qt-row",
+  setup(props, context) {
+    const viewRef = ref();
+    return {
+      viewRef,
+      ...useBaseView(viewRef),
+    };
+  },
+});
+</script>
+
+<style scoped>
+.qt-ui-row-css {
+  display: flex;
+  flex-direction: row;
+}
+</style>

package/rules/.source/quicktvui/src/scroll-view/QTIScrollView.ts

@@ -0,0 +1,7 @@
+import { QTIView } from "../view/QTIView";
+
+export interface QTIScrollView extends QTIView {
+  scrollTo(x: number, y: number): void;
+
+  scrollToWithOptions(x: number, y: number, duration: number): void;
+}