@quicktvui/ai 1.0.5 → 1.0.7

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

@@ -0,0 +1,156 @@
+import qtType, { typeEnum, QtChangeData } from "./types";
+import { qtRefUid } from "./watch";
+
+class QtArray extends Array {
+  __v_raw: any;
+  shift() {
+    if (this.__v_raw.length) {
+      // @ts-ignore
+      const start = 0;
+      const end = 0;
+      const deleteCount = 1;
+      // @ts-ignore
+      const changeData = qtType.getTargetType(this.__v_raw, typeEnum.shift);
+      if (changeData) {
+        changeData.deleteCount += deleteCount;
+      } else {
+        const datas = new QtChangeData(start, end, deleteCount);
+        // @ts-ignore
+        qtType.setType(this.__v_raw, typeEnum.shift, datas);
+        // @ts-ignore
+        qtType
+          .getFlag(this.__v_raw)
+          .set(typeEnum.expectCangeNum, this.__v_raw.length);
+      }
+    }
+    return super.shift();
+  }
+  unshift(...items: any[]) {
+    if (items.length) {
+      let start = 0;
+      let end = items.length - 1;
+      // @ts-ignore
+      let changeData = qtType.getTargetType(this.__v_raw, typeEnum.unshift);
+      if (!changeData) {
+        changeData = new QtChangeData(start, end);
+        // @ts-ignore
+        qtType.setType(this.__v_raw, typeEnum.unshift, changeData);
+        // @ts-ignore
+        qtType
+          .getFlag(this.__v_raw)
+          .set(typeEnum.expectCangeNum, this.__v_raw.length + items.length);
+      } else {
+        // console.log(changeData.start, changeData.end)
+        // changeData.end += items.length
+      }
+      qtRefUid.addUidBatch(items);
+    }
+    return super.unshift(...items);
+  }
+  push(...items: any[]) {
+    if (items.length) {
+      // @ts-ignore
+      const start = this.__v_raw.length;
+      const end = start + items.length - 1;
+      // @ts-ignore
+      const changeData = qtType.getTargetType(this.__v_raw, typeEnum.push);
+      if (changeData) {
+        changeData.end += items.length;
+      } else {
+        const datas = new QtChangeData(start, end);
+        // @ts-ignore
+        qtType.setType(this.__v_raw, typeEnum.push, datas);
+      }
+      qtRefUid.addUidBatch(items);
+    }
+    return super.push(...items);
+  }
+  splice(start: number, deleteCount: number, ...items: any[]) {
+    if (start < 0) {
+      start = 0;
+    } //防止索引越界
+    // @ts-ignore
+    if (deleteCount === undefined && this.__v_raw.length) {
+      // @ts-ignore
+      deleteCount = this.__v_raw.length - start;
+    }
+    // @ts-ignore
+    if (start >= this.__v_raw.length || deleteCount < 0) {
+      //防止索引越界
+      deleteCount = 0;
+    }
+
+    let end = start;
+    if (items && items.length) {
+      end = start + items.length - 1;
+    } else {
+      end = -1;
+    }
+
+    let changeData = qtType.getTargetType(this.__v_raw, typeEnum.splice);
+    if (!changeData) {
+      changeData = new QtChangeData(start, end, deleteCount);
+      qtType.setType(this.__v_raw, typeEnum.splice, changeData);
+      qtType
+        .getFlag(this.__v_raw)
+        .set(
+          typeEnum.expectCangeNum,
+          this.__v_raw.length + items.length - deleteCount - start,
+        );
+    }
+    if (deleteCount <= 0) {
+      qtType.recordArrChangeProps(this.__v_raw, start, start + items.length);
+    } else if (items && items.length) {
+      qtType.recordArrChangeProps(this.__v_raw, start, start + deleteCount);
+    } else {
+      qtType.recordArrChangeProps(this.__v_raw, start, start);
+    }
+
+    if (items) {
+      for (let i = deleteCount; i < items.length; i++) {
+        qtRefUid.addUid(items[i]);
+      }
+    }
+    return super.splice(start, deleteCount, ...items);
+  }
+  pop() {
+    // @ts-ignore
+    if (this.__v_raw.length) {
+      // @ts-ignore
+      const start = this.__v_raw.length - 1;
+      const end = start;
+      const deleteCount = 1;
+      // @ts-ignore
+      const changeData = qtType.getTargetType(this.__v_raw, typeEnum.pop);
+      if (changeData) {
+        changeData.start -= 1;
+        changeData.deleteCount += deleteCount;
+      } else {
+        const datas = new QtChangeData(start, end, deleteCount);
+        // @ts-ignore
+        qtType.setType(this.__v_raw, typeEnum.pop, datas);
+      }
+    }
+    return super.pop();
+  }
+  concat(items: any[]) {
+    if (items.length) {
+      // @ts-ignore
+      const start = this.__v_raw.length;
+      const end = start + items.length - 1;
+      // @ts-ignore
+      let changeData = qtType.getTargetType(this.__v_raw, typeEnum.concat);
+      if (changeData) {
+        changeData.end += items.length;
+      } else {
+        changeData = new QtChangeData(start, end);
+        changeData.dataArr = items;
+        // @ts-ignore
+        qtType.setType(this.__v_raw, typeEnum.concat, changeData);
+      }
+      qtRefUid.addUidBatch(items);
+    }
+    return super.concat(...items);
+  }
+}
+export default QtArray;

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

@@ -0,0 +1,143 @@
+import { toRaw } from "vue";
+import { QtChangeData } from "./types";
+import type { IQtWatchOptions } from "./watch";
+const compareType = (oldObj: object, newObj: object) => {
+  if (
+    oldObj === null ||
+    newObj === null ||
+    oldObj === undefined ||
+    newObj === undefined
+  ) {
+    return oldObj === newObj;
+  }
+  if (!oldObj || !newObj) {
+    return typeof oldObj === typeof newObj;
+  }
+  return oldObj.constructor.name === newObj.constructor.name;
+};
+
+const compareObj = (oldObj: any, newObj: any) => {
+  if (oldObj.__qt_key_ && newObj.__qt_key_) {
+    return oldObj.__qt_key_ === newObj.__qt_key_;
+  }
+  return JSON.stringify(oldObj) === JSON.stringify(newObj);
+};
+const compareNode = (oldNode: any, newNode: any) => {
+  if (!compareType(oldNode, newNode)) {
+    return false;
+  }
+  if (typeof oldNode === "object") {
+    return compareObj(oldNode, newNode);
+  }
+  return oldNode == newNode;
+};
+
+const qtDiffNodeChange = (oldNode: any, newNode: any) => {
+  let diffRes = false;
+  if (oldNode.__qt_key_ && newNode.__qt_key_) {
+    // console.log(oldNode.__qt_key_ !== newNode.__qt_key_, '-oldNode.__qt_key_ !== newNode.__qt_key_')
+    diffRes = oldNode.__qt_key_ === newNode.__qt_key_;
+  }
+  if (diffRes && oldNode.__qt_change_num_ && newNode.__qt_change_num_) {
+    diffRes = newNode.__qt_change_num_ > oldNode.__qt_change_num_;
+  }
+  return diffRes;
+};
+
+export const qtDiff = (
+  oldt: any[],
+  newt: any[],
+  options: Pick<IQtWatchOptions, "update" | "insert" | "delete" | "add">,
+) => {
+  // console.log('diff-', oldt, newt)
+  // if(oldt.length===0) return //init 初始化
+  // if(newt.length===0) return //clear 清空
+
+  // const adds = new QtChangeData(-1,-1)
+  const updates = new QtChangeData(-1, -1);
+  const deletes = new QtChangeData(-1, -1);
+  const inserts = new QtChangeData(-1, -1);
+
+  for (let i = 0; i < oldt.length; i++) {
+    //比较oldt中存在但在newt中不存在的元素
+    // 删除newt中不存在的节点
+    const oldItem = oldt[i];
+    const newItem = newt.find((nItem) => compareNode(oldItem, nItem));
+    if (newItem) {
+      if (deletes.deleteCount > 0) {
+        options.delete(deletes.start, deletes.deleteCount);
+        deletes.resetData();
+      }
+    } else {
+      if (deletes.start === -1) {
+        deletes.start = i;
+        deletes.deleteCount = 1;
+      } else {
+        deletes.deleteCount++;
+      }
+    }
+  }
+  if (deletes.deleteCount > 0) {
+    options.delete(deletes.start, deletes.deleteCount);
+  }
+
+  let repeatOldIndex = -1;
+  for (let i = 0; i < newt.length; i++) {
+    //比较newt中存在但在oldt中不存在的元素
+    const newItem = newt[i];
+    const oldItem = oldt.find((oItem, oIndex) => {
+      if (compareNode(oItem, newItem) && oIndex > repeatOldIndex) {
+        repeatOldIndex = oIndex; //已经比较过的不在比较
+        return true;
+      }
+      return false;
+    });
+    if (oldItem) {
+      if (inserts.datas.size) {
+        options.insert(inserts.start, Array.from(inserts.datas.values()));
+        inserts.resetData();
+      }
+      const isChange = qtDiffNodeChange(oldItem, newItem);
+      // console.log(isChange, i, '--updates', oldItem.__qt_change_num_, newItem.__qt_change_num_)
+
+      if (isChange) {
+        if (updates.start === -1) {
+          updates.start = i;
+          updates.updateCount = 1;
+          updates.rootUpdateCount = 1;
+          updates.end = updates.start + updates.updateCount;
+        } else {
+          if (i > updates.start && i <= updates.end) {
+            updates.updateCount++;
+            updates.end++;
+            updates.rootUpdateCount++;
+          } else {
+            options.update(updates.start, updates, oldt);
+            updates.resetData();
+            updates.start = i;
+            updates.updateCount = 1;
+            updates.rootUpdateCount = 1;
+            updates.end = updates.start + updates.updateCount;
+          }
+        }
+        updates.datas.set(i, toRaw(newItem));
+      }
+    } else {
+      if (inserts.start === -1) {
+        inserts.start = i;
+      }
+      inserts.datas.set(i, toRaw(newItem));
+      if (updates.datas.size) {
+        options.update(updates.start, updates, oldt);
+        updates.resetData();
+      }
+    }
+  }
+  if (updates.datas.size) {
+    options.update(updates.start, updates, oldt);
+  }
+
+  if (inserts.datas.size) {
+    options.add(Array.from(inserts.datas.values()));
+  }
+};

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

@@ -0,0 +1,205 @@
+import { isObject, isArray } from "@vue/shared";
+import { qtTrack, qtTrigger } from "./effect";
+import QtArray from "./qtArray";
+import qtType, { typeEnum } from "./types";
+import { isReactive, toRaw } from "vue";
+import { qtRefUid } from "./watch";
+
+export const enum emReactiveFlags {
+  IS_REACTIVE = "__v_isReactive",
+  WATCH_ALL = "__ls_watchAll",
+  WATCH_RAW = "__v_raw",
+  RESET_REF_VALUE = "__ls_reset_ref_value", //重置ref对象value值，时的类型
+  NEW_SET = "__ls_new_set",
+  qtPath = "__qt_path",
+  qtRoot = "__qt_root",
+  qtArrDeth = "__qt_arr_deth",
+}
+export const isTrackProp = (target: object, prop: string | symbol) => {
+  // && (typeof prop !== 'symbol')
+  if (typeof prop === "string") {
+    return !prop.startsWith("__qt_");
+  }
+  return target.hasOwnProperty(prop);
+};
+const reactiveMap = new WeakMap();
+
+/**
+ * 获取指定层级的父级对象
+ * @param root 根对象
+ * @param paths 路径
+ * @param layer 指定要获取哪一级的对象
+ */
+export const qtGetParent = (root: object, paths: any[], layer: number) => {
+  if (!isObject(root)) return;
+  if (layer >= paths.length - 1) {
+    return root;
+  }
+  if (layer < 0) {
+    layer = 0;
+  }
+  const start = 1;
+  const end = paths.length - 1 - layer;
+  let res = root;
+  // console.log(root, '--getparent', paths, start, end)
+  for (let i = start; i <= end; i++) {
+    const path = paths[i];
+    res = res[path];
+    if (!isObject(res)) {
+      break;
+    }
+  }
+  return res;
+};
+
+const getReactiveConfig = (
+  root?: any,
+  paths: any[] = [],
+  __qt_arr_deth = 1,
+): ProxyHandler<any> => {
+  return {
+    get(target, prop, receiver) {
+      if (prop === emReactiveFlags.qtRoot) {
+        return root;
+      }
+      if (prop === emReactiveFlags.qtPath) {
+        return paths;
+      }
+      if (prop === emReactiveFlags.qtArrDeth) {
+        return __qt_arr_deth;
+      }
+      if (prop === emReactiveFlags.IS_REACTIVE) {
+        return true;
+      }
+      if (
+        prop === emReactiveFlags.WATCH_ALL ||
+        prop === emReactiveFlags.WATCH_RAW
+      ) {
+        return target;
+      }
+      qtTrack(target, prop);
+      // console.log(prop, '--get')
+      const result = Reflect.get(target, prop, receiver);
+      if (isObject(result)) {
+        const res = createReactiveObject(
+          result,
+          root,
+          [...paths, prop],
+          isArray(result) ? __qt_arr_deth + 1 : __qt_arr_deth,
+        );
+        // console.log(result, '--', prop, target)
+        return res;
+      }
+      return result;
+    },
+    set(target: any, prop, value, receiver) {
+      let oldValue = target[prop];
+      if (isReactive(value)) {
+        value = toRaw(value);
+      }
+      if (isObject(value) && !isArray(value) && typeof prop === "string") {
+        if (!value.__qt_key_) {
+          if (isObject(oldValue)) {
+            // && !isArray(target)
+            value.__qt_key_ = oldValue.__qt_key_ || qtRefUid.createUid(prop); //标记唯一值，diff对比时使用
+          } else {
+            value.__qt_key_ = qtRefUid.createUid(prop);
+          }
+        }
+        if (!value.__qt_change_num_) {
+          if (isObject(oldValue)) {
+            // && !isArray(target)
+            value.__qt_change_num_ = oldValue.__qt_change_num_ || 1; //标记唯一值，diff对比时使用
+          } else {
+            value.__qt_change_num_ = 1; //标记节点是否被修改，diff对比使用
+          }
+        }
+      }
+      // const _value = isObject(value) ? createReactiveObject(value, root, [...paths, prop]): value
+      const res = Reflect.set(target, prop, value, receiver);
+      try {
+        if (isTrackProp(target, prop)) {
+          if (oldValue != value) {
+            if (
+              isObject(value) &&
+              value.__qt_change_num_ &&
+              qtType.checkArrChangeProps(target, prop)
+            ) {
+              value.__qt_change_num_++;
+            }
+            const _root = receiver[emReactiveFlags.qtRoot];
+            const _path = receiver[emReactiveFlags.qtPath];
+            // console.log(prop, '--reactive--')
+            if (_path && _path.length && !isReactive(value)) {
+              const firstProp = _path[0];
+              const _firstObj = _root[firstProp]; //[emReactiveFlags.WATCH_RAW]
+              // const parentObj = getParent(_root, _prop, 1)//父级对象
+              // console.log(_root, '-qtRoot-', _path, value, _firstObj)
+              if (isObject(_firstObj) && _firstObj.__qt_change_num_) {
+                _firstObj.__qt_change_num_++;
+              }
+              const _prop =
+                Array.isArray(target) && prop === "length" ? "" : prop; //length并不是数组真正要更新的子项，应该是目标数组删除或新增了数据，如第二层的数组pop删除了一条数据
+              qtType.changeOfsetType(
+                _root,
+                _path,
+                _firstObj,
+                _prop,
+                receiver[emReactiveFlags.qtArrDeth],
+              );
+              qtTrigger(_root, firstProp, _firstObj, typeEnum.set, oldValue);
+            } else if (Array.isArray(target) && !isNaN(Number(prop))) {
+              const isCollect = qtType.changeTypeData(target, prop, value);
+              if (!isCollect) {
+                qtType.changeOfsetType(target, prop, value);
+              }
+              qtTrigger(target, prop, value, typeEnum.set, oldValue);
+            } else {
+              qtType.changeOfsetType(target, prop, value); //对象的操作类型记录-带验证
+              qtTrigger(target, prop, value, typeEnum.set, oldValue);
+            }
+          }
+        }
+      } catch (error) {
+        console.warn(error);
+      }
+      return res;
+    },
+  };
+};
+
+function createReactiveObject(
+  data: object,
+  root?: any,
+  paths?: any[],
+  __qt_arr_deth = 1,
+) {
+  if (!isObject(data)) {
+    return data;
+  }
+  if ((data as any)[emReactiveFlags.IS_REACTIVE]) return data;
+
+  if (Array.isArray(data)) {
+    // @ts-ignore
+    data.__proto__ = new QtArray();
+  }
+  if (!root) {
+    root = data;
+  }
+  return new Proxy(data, getReactiveConfig(root, paths, __qt_arr_deth));
+}
+
+export function qtReactive(data: object, parent?: any, path?: any) {
+  const prevProxy = reactiveMap.get(data);
+  if (prevProxy) {
+    return prevProxy;
+  }
+
+  const proxyObj = createReactiveObject(data, parent, path);
+  reactiveMap.set(data, proxyObj);
+  return proxyObj;
+}
+
+export function qtToReactive(value: any, parent?: any, path?: any) {
+  return isObject(value) ? qtReactive(value, parent, path) : value;
+}

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

@@ -0,0 +1,98 @@
+import {
+  qtIsTracking,
+  qtTrackEffects,
+  qtTrigger,
+  qtTriggerEffects,
+} from "./effect";
+import { qtToReactive, emReactiveFlags } from "./reactive";
+import { qtCloneObj } from "./watch";
+
+class QtRefImpl<T extends Object> {
+  public dep: Set<any> = new Set();
+  public __v_isRef = true;
+  public _value: any;
+  public _rawValue: any;
+  constructor(_rawValue: object) {
+    this._rawValue = qtCloneObj(_rawValue);
+    this._value = qtToReactive(this._rawValue);
+  }
+  get value(): T {
+    if (qtIsTracking()) {
+      qtTrackEffects(this.dep || (this.dep = new Set())); //依赖收集
+    }
+    return this._value;
+  }
+  set value(newV: T) {
+    newV = qtCloneObj(newV);
+    if (newV !== this._rawValue) {
+      this._value = qtToReactive(newV);
+      //触发watchALl依赖监听
+      qtTrigger(
+        this._rawValue,
+        emReactiveFlags.WATCH_ALL,
+        newV,
+        emReactiveFlags.RESET_REF_VALUE,
+        this._rawValue,
+      );
+      // 触发属性监听
+      qtTriggerEffects(
+        this.dep,
+        this._rawValue,
+        undefined,
+        newV,
+        "",
+        this._rawValue,
+      );
+      this._rawValue = newV;
+    }
+  }
+}
+
+export interface IQtRef<T = any> {
+  value: T; //自定义返回类型，隐藏示例内部属性，防止被修改
+  [k: string]: any;
+}
+
+function qtCreateRef<T extends Array<any>>(value?: T): QtRefImpl<T> {
+  return new QtRefImpl<T>(value || []);
+}
+export function qtRef<T extends Array<any>>(value?: T): IQtRef<T> {
+  return qtCreateRef<T>(value);
+}
+function qtCreateRefObject<T extends object>(value?: T): QtRefImpl<T> {
+  return new QtRefImpl<T>(value || {});
+}
+export function qtRefObject<T extends object>(value?: T): IQtRef<T> {
+  return qtCreateRefObject<T>(value);
+}
+
+export interface IQtTabDatas {
+  // tab
+  _id: string;
+  type: number;
+  text: string;
+  titleSize: number;
+  decoration: { left: number; right: number };
+  // tab-waterfall
+  useDiff?: boolean;
+  disableScrollOnFirstScreen?: boolean;
+  firstFocusTargetID?: string;
+  bindingPlayer?: string;
+  content: Array<{
+    title?: string;
+    titleStyle?: any;
+    itemList: Array<{
+      style: any;
+      [prop: string]: any;
+    }>;
+    style: any;
+    placeholder?: { enable: boolean };
+    [k: string]: any;
+  }>;
+  [k: string]: any;
+}
+export function qtTabsRef(
+  value?: Array<IQtTabDatas>,
+): IQtRef<Array<IQtTabDatas>> {
+  return qtCreateRef<Array<IQtTabDatas>>(value);
+}