annil 1.16.0 → 1.18.0

package/src/api/DefineComponent/normalizeOptions/initComputed/computedUpdater.ts

@@ -1,51 +0,0 @@
-import { deepEqual } from "../../../../utils/deepEqual";
-import type { Instance } from "../../../RootComponent/Instance/RootComponentInstance";
-import { deepProxy, getOriginalValue } from "./data-tracer";
-import { removeSubDependences } from "./dependencesOptimize";
-import type { ComputedDependence } from "./initComputedAndGetCache";
-
-export function computedUpdater(this: Instance): void {
-  for (const key in this.data.__computedCache__) {
-    const itemCache = this.data.__computedCache__[key];
-    let changed = false;
-    outLook: for (const dep of itemCache.dependences) {
-      let curdepVal: unknown = this.data;
-      for (const path of dep.paths) {
-        // 如果依赖值为null,则直接跳出
-        if (curdepVal === null) {
-          changed = true;
-          break outLook;
-        }
-        curdepVal = (curdepVal as Record<string, unknown>)[path];
-      }
-      // 检查依赖值是否改变
-      if (!deepEqual(curdepVal, dep.val)) {
-        changed = true;
-        break;
-      }
-    }
-    if (changed) {
-      const newDependences: ComputedDependence[] = [];
-      const proxyThis = new Proxy(this, {
-        get(target, prop, receiver) {
-          if (prop === "data") {
-            return deepProxy(target.data, newDependences);
-          }
-          return Reflect.get(target, prop, receiver);
-        },
-        set() {
-          throw "不可以在计算属性中修改实例的属性";
-        },
-      });
-      const newValue = itemCache.method.call(proxyThis);
-      // 更新值不会立即再次进入**函数,而是当前**函数运行完毕后触发**函数,\
-      this.setData({
-        [key]: getOriginalValue(newValue),
-      });
-      // 更新依赖(优化)
-      this.data.__computedCache__[key].dependences = removeSubDependences(newDependences);
-      // 有一个计算属性更新就重新更新所有计算互相,避免后置依赖导致前置依赖错误
-      return computedUpdater.call(this);
-    }
-  }
-}

package/src/api/DefineComponent/normalizeOptions/initComputed/data-tracer.ts

@@ -1,62 +0,0 @@
-import { removePreviousDependence } from "./dependencesOptimize";
-import type { ComputedDependence } from "./initComputedAndGetCache";
-
-// 判断属性字段是否为对象自身的属性
-function isOwnProp(target: object, prop: string) {
-  return Object.prototype.hasOwnProperty.call(target, prop);
-}
-export function deepProxy(
-  data: object,
-  dependences: ComputedDependence[],
-  basePath: string[] = [],
-): object {
-  let ignoreProxy = false;
-  const handler = {
-    get<T extends object>(target: T, prop: keyof T & string) {
-      if (prop === "__original__") {
-        return target;
-      }
-      const val = target[prop];
-
-      // 原型链上的属性不收集依赖,比如数组上的方法 slice map forEach 对象上的toString等
-      if ((val !== undefined && (isOwnProp(target, prop) === false)) || ignoreProxy) {
-        return typeof val === "function" ? val.bind(target) : val; // : val 覆盖测试不到.
-      }
-      removePreviousDependence(dependences, basePath);
-
-      const curPath = basePath.concat(prop);
-
-      dependences.push({ paths: curPath, val });
-
-      // 非对象不代理
-      if (typeof val !== "object" || val === null) return val;
-      return deepProxy(val, dependences, curPath);
-    },
-    // 使用in操作符时处理
-    has(target: Record<string, unknown>, prop: string) {
-      removePreviousDependence(dependences, basePath);
-      const curPath = basePath.concat(prop);
-      dependences.push({ paths: curPath, val: target[prop] });
-      return Reflect.has(target, prop);
-    },
-    // 拦截Object.keys, Object.values, Object.entries时后续不收集依赖ignoreProxy=true
-    ownKeys(target: object) {
-      ignoreProxy = true;
-      return Reflect.ownKeys(target);
-    },
-    set(_target: object, prop: string) {
-      throw Error(`${prop}字段是只读的`);
-    },
-  };
-
-  return new Proxy(data, handler);
-}
-
-// 如果是代理对象可以从__original__中获取原始值,否则返回自身
-export function getOriginalValue(value: { __original__?: unknown }): unknown {
-  if (typeof value !== "object" || value === null || value.__original__ === undefined) {
-    return value;
-  }
-
-  return value.__original__;
-}

package/src/api/DefineComponent/normalizeOptions/initComputed/dependencesOptimize.ts

@@ -1,45 +0,0 @@
-import type { ComputedDependence } from "./initComputedAndGetCache";
-
-// 删除子依赖
-export function removeSubDependences(dependences: ComputedDependence[]) {
-  // 把dependences按照路径长度排序
-  dependences.sort((a, b) => a.paths.length - b.paths.length);
-  // 从最长的路径开始遍历,如果当前路径是上一个路径的子路径,则删除当前路径
-  for (let f = 0; f < dependences.length; f++) {
-    const sortPath = dependences[f].paths;
-    // 从后往前遍历,删除子依赖,保留父依赖
-    for (let i = dependences.length - 1; i > f; i--) {
-      const curPath = dependences[i].paths;
-      // 检查 curPath 是否以 sortPath 开头，并且下一个元素是子路径
-      if (curPath.length > sortPath.length && curPath.slice(0, sortPath.length).toString() === sortPath.toString()) {
-        dependences.splice(i, 1);
-      }
-    }
-  }
-  // 去重
-  return dependences.filter((dep, index, self) =>
-    index === self.findIndex((t) => (
-      t.paths.toString() === dep.paths.toString()
-    ))
-  );
-}
-//  const testA = removeSubDependences([{paths: ["test",'aaa']},{paths: ["test"]}]);
-//  console.log('testA', testA); // [{paths: ["test"]}]
-//  const testB = removeSubDependences([{paths: ["test"]},{paths: ["test",'aaa']},{paths: ["test",'aaa','bbb']}]);
-//  console.log('testB', testB); // [{paths: ["test"]}]
-//  const testC = removeSubDependences([{paths: ["test"]},{paths: ["test1"]}]);
-//  console.log('testC', testC); // [{paths: ["test"]},{paths: ["test1"]}]
-//  const testD = removeSubDependences([{paths: ["test"]},{paths: ["test"]}]);
-//  console.log('testD', testD); // [{paths: ["test"]}]
-// 当前依赖是上一个依赖的子依赖时,去除上一个依赖
-export function removePreviousDependence(dependences: ComputedDependence[], basePath: string[]) {
-  if (dependences.length === 0 || basePath.length === 0) return dependences;
-
-  const lastDependence = dependences[dependences.length - 1];
-
-  if (lastDependence.paths.toString() === basePath.toString()) {
-    dependences.pop();
-  }
-
-  return dependences;
-}

package/src/api/DefineComponent/normalizeOptions/initComputed/index.ts

@@ -1,42 +0,0 @@
-import type { Func } from "hry-types/src/Misc/Func";
-import { deepClone } from "../../../../utils/deepClone";
-import { isEmptyObject } from "../../../../utils/isEmptyObject";
-import { nonNullable } from "../../../../utils/nonNullable";
-import type { ComputedConstraint } from "../../../RootComponent/Computed/ComputedConstraint";
-import type { Instance } from "../../../RootComponent/Instance/RootComponentInstance";
-import { getPathsValue } from "../watchHandler/getPathsValue";
-import { hasComputedPath } from "../watchHandler/hasComputedPath";
-import { initComputedAndGetCache } from "./initComputedAndGetCache";
-/**
- * 初始化会在2个时间渲染,一个是observers.**的回调函数,一个是attached周期。
- * @param computedConfig
- * @param watchConfig
- * @param mark
- * @returns
- */
-export function initComputed(
-  computedConfig: ComputedConstraint,
-  watchConfig: Record<string, Func>,
-  // mark?: string,
-) {
-  return function(this: Instance) {
-    // __computedCache__ 用来避免重复初始化。
-
-    const __computedInitCache__ = initComputedAndGetCache.call(this, computedConfig);
-    // 缓存放入data中
-    this.data.__computedCache__ = __computedInitCache__;
-    // 为__watchOldValue__赋值(watchPath中包含计算属性的值的key)
-    if (!isEmptyObject(watchConfig)) {
-      // 有watchConfig配置时,watchOldValue已经初始过了,所以必有__watchOldValue__
-      const watchOldValue: Record<string, unknown[]> = nonNullable(this.data.__watchOldValue__);
-      for (const path in watchConfig) {
-        // 只针对watchPath中包含计算属性的值的key进行赋值
-        if (hasComputedPath(path, Object.keys(computedConfig))) {
-          watchOldValue[path] = deepClone(getPathsValue(this.data, path));
-        }
-      }
-    }
-    //   watch回调时会判断__computedInited__是否为true,如果为false则不执行watch回调
-    this.data.__computedInited__ = true;
-  };
-}

package/src/api/DefineComponent/normalizeOptions/initComputed/initComputedAndGetCache.ts

@@ -1,105 +0,0 @@
-import type { Func } from "hry-types/src/Misc/Func";
-
-import type { Instance } from "../../../RootComponent/Instance/RootComponentInstance";
-
-import { deepProxy, getOriginalValue } from "./data-tracer";
-import { removeSubDependences } from "./dependencesOptimize";
-export type ComputedDependence = { paths: string[]; val: unknown };
-
-type ItemCache = {
-  dependences: ComputedDependence[];
-  method: Func;
-  value: unknown;
-};
-
-type ComputedId = string;
-
-export type ComputedCache = Record<ComputedId, ItemCache>;
-
-/**
- * 如果依赖列表某项的首个字段值为undefined并且字段为其他计算属性字段(即被依赖的计算字段写在了依赖他的计算字段后面) 返回false, 否则返回true表示依赖有效。
- */
-function isValidDependences(dependences: ComputedDependence[], computedKeys: string[]): boolean {
-  for (const { paths: path, val } of dependences) {
-    if ((val === undefined) && computedKeys.includes(path[0])) {
-      return false;
-    }
-  }
-
-  // 依赖有效
-  return true;
-}
-export function _initComputedAndGetCache(
-  this: Instance,
-  computedConfig: Record<string, Func>,
-  uninitedkeys: string[],
-  computedCache: ComputedCache,
-): ComputedCache {
-  for (const key of uninitedkeys) {
-    const computedFunc = computedConfig[key];
-    const dependences: ComputedDependence[] = [];
-    const proxyThis = new Proxy(this, {
-      get(target, prop: string, receiver) {
-        if (prop === "data") {
-          return deepProxy(target.data, dependences);
-        }
-        return Reflect.get(target, prop, receiver);
-      },
-      set() {
-        throw "不可以在计算属性中修改实例的属性";
-      },
-    });
-    // 通过代理data获取计算字段的初始值和依赖
-
-    let initValue;
-    let errMsg;
-    try {
-      initValue = computedFunc.call(proxyThis);
-    } catch (e) {
-      errMsg = e;
-    }
-    // 计算属性执行失败,直接返回
-    // 去除当前已初始的计算属性key
-    uninitedkeys = uninitedkeys.filter(ele => ele !== key);
-
-    // 验证依赖是否有效
-    if (isValidDependences(dependences, uninitedkeys)) {
-      // 依赖合法还有错误就报错
-      if (errMsg) {
-        throw errMsg;
-      }
-      initValue = getOriginalValue(initValue);
-      // 把计算属性初始值加入到data中 此时会引起watch和observers触发
-      this.setData({
-        [key]: initValue,
-      });
-      computedCache[key] = {
-        dependences: removeSubDependences(dependences),
-        method: computedFunc,
-        value: initValue,
-      };
-    } else {
-      // 把当前依赖不正确的key放到后面去
-      uninitedkeys.push(key);
-    }
-  }
-  // 看uninitedkey是否未空，空表示所有依赖收集完毕直接返回
-  if (uninitedkeys.length === 0) {
-    return computedCache;
-  }
-
-  // uninitedkey不为空,递归调用
-  return _initComputedAndGetCache.call(this, computedConfig, uninitedkeys, computedCache);
-}
-
-/**
- * 把计算属性初始值setData并返回缓存
- * @param this
- * @param computedConfig 计算属性配置
- */
-export function initComputedAndGetCache(
-  this: Instance,
-  computedConfig: Record<string, Func>,
-): ComputedCache {
-  return _initComputedAndGetCache.call(this, computedConfig, Object.keys(computedConfig), {});
-}

package/src/api/DefineComponent/normalizeOptions/injectInfoHandler.ts

@@ -1,51 +0,0 @@
-import type { IInjectInfo } from "../../..";
-import type { InjectKey } from "../../InstanceInject/instanceConfig";
-import type { FinalOptionsOfComponent } from ".";
-/**
- * 把injectInfo字段合并到finalOptionsForComponent
- * @remarks 规则：
- * 1. behaviors字段 push
- * 2. 对象字段 没有的话直接赋值，有的话Object.assign
- * @param finalOptionsForComponent
- * @param injectInfo
- * @returns finalOptionsForComponent
- */
-function mergeOptions(
-  finalOptionsForComponent: FinalOptionsOfComponent,
-  injectInfo: IInjectInfo,
-): FinalOptionsOfComponent {
-  for (const key in injectInfo) {
-    const isInjectKey = key as InjectKey;
-    const injectVal = injectInfo[isInjectKey];
-
-    if (key in finalOptionsForComponent) {
-      const renamedKey = key as keyof FinalOptionsOfComponent;
-      const originalVal = finalOptionsForComponent[renamedKey];
-      switch (isInjectKey) {
-        case "behaviors":
-          finalOptionsForComponent["behaviors"].push(...injectVal as string[]);
-
-          break;
-
-        default:
-          // @ts-ignore
-          finalOptionsForComponent[renamedKey] = Object.assign(originalVal, injectVal);
-
-          break;
-      }
-    } else {
-      // @ts-ignore
-      finalOptionsForComponent[key] = injectVal;
-    }
-  }
-
-  return finalOptionsForComponent;
-}
-export function injectInfoHandler(
-  finalOptionsForComponent: FinalOptionsOfComponent,
-  injectInfo: IInjectInfo | undefined,
-): FinalOptionsOfComponent {
-  if (!injectInfo) return finalOptionsForComponent;
-
-  return mergeOptions(finalOptionsForComponent, injectInfo);
-}

package/src/api/DefineComponent/normalizeOptions/internalFieldProtection.ts

@@ -1,27 +0,0 @@
-import type { FinalOptionsOfComponent } from ".";
-
-// 内部字段
-const internalFiled = {
-  methods: ["disposer"],
-  data: ["__computedCache__", "__watchOldValue__"], // "__throttleDebounce__" 放在之前的位置验证
-};
-
-/**
- * 报错的形式避免输入字段和内部字段冲突,保证config下不包含内部预定字段(列表)
- */
-export function InternalFieldProtection(finalOptionsForComponent: FinalOptionsOfComponent) {
-  const methodsFieldKeys = Object.keys(finalOptionsForComponent.methods);
-  const dataFieldKeys = Object.keys(finalOptionsForComponent.data);
-
-  for (const key of methodsFieldKeys) {
-    if (internalFiled.methods.includes(key)) {
-      throw Error(`methods配置中的${key}字段已被内部字段占用`);
-    }
-  }
-  for (const key of dataFieldKeys) {
-    if (internalFiled.data.includes(key)) {
-      /* istanbul ignore next 同上*/
-      throw Error(`data配置中的${key}字段已被内部字段占用`);
-    }
-  }
-}

package/src/api/DefineComponent/normalizeOptions/otherFieldsHandle.ts

@@ -1,29 +0,0 @@
-import type { RootComponentDefinitionRuntime } from "../../RootComponent/returnType";
-import type { FinalOptionsOfComponent } from ".";
-
-/**
- * 其他字段加入到componentOptions对应字段配置中
- */
-export function otherFieldsHandle(
-  finalOptions: FinalOptionsOfComponent,
-  rootComponentOptions: Omit<RootComponentDefinitionRuntime, "customEvents" | "events">,
-) {
-  let key: keyof Omit<RootComponentDefinitionRuntime, "customEvents" | "events">;
-  for (key in rootComponentOptions) {
-    const config = rootComponentOptions[key];
-    if (config === undefined) continue;
-    if (key === "behaviors") {
-      finalOptions[key].push(...config as string[]);
-    } else if (typeof config === "object") {
-      // @ts-ignore
-      finalOptions[key] = finalOptions[key] || {};
-      // @ts-ignore
-      Object.assign(finalOptions[key], config);
-    } else if (typeof config === "boolean") {
-      finalOptions[key as "isPage"] = config;
-    } else {
-      // console.warn(`选项的${key}字段,无特殊处理`);
-      finalOptions[key] = config;
-    }
-  }
-}

package/src/api/DefineComponent/normalizeOptions/sameFuncFieldsCollect.ts

@@ -1,23 +0,0 @@
-import type { Func } from "hry-types/src/Misc/Func";
-
-import type { RootComponentDefinitionRuntime } from "../../RootComponent/returnType";
-import type { SubComponentDefinitionRuntime } from "../../SubComponent/returnType";
-import type { SameFuncOptions } from ".";
-
-/**
- * 把配置为函数的字段方法收集到funcOptions中
- */
-export function sameFuncFieldsCollect(
-  options: SubComponentDefinitionRuntime | RootComponentDefinitionRuntime,
-  funcOptions: SameFuncOptions,
-) {
-  let key: keyof SameFuncOptions;
-  for (key in funcOptions) {
-    const optionsKeyConfig: Record<string, Func> | undefined = options[key];
-    if (optionsKeyConfig) {
-      for (const _key in optionsKeyConfig) {
-        (funcOptions[key][_key] ||= []).push(optionsKeyConfig[_key]);
-      }
-    }
-  }
-}

package/src/api/DefineComponent/normalizeOptions/sameFuncOptionsHandle.ts

@@ -1,36 +0,0 @@
-import type { Func } from "hry-types/src/Misc/_api";
-import { isEmptyObject } from "../../../utils/isEmptyObject";
-import type { FinalOptionsOfComponent, SameFuncOptions } from ".";
-/**
- * 把函数配置放入一个配置中依次运行
- */
-function _sameFuncOptionsHandle(config: Record<string, unknown>, configList: Record<string, Func[]>) {
-  for (const key in configList) {
-    config[key] = function(...args: unknown[]) {
-      configList[key].forEach(ele => ele.call(this, ...args));
-    };
-  }
-}
-/**
- * 把函数列表配置放入一个配置中循环依次运行
- */
-export function sameFuncOptionsHandle(
-  finalOptionsForComponent: FinalOptionsOfComponent,
-  isPage: boolean | undefined,
-  funcOptions: SameFuncOptions,
-) {
-  if (isPage) {
-    // 页面时 生命周期方法(即 on 开头的方法),(https://developers.weixin.qq.com/miniprogram/dev/framework/custom-component/component.html)
-    if (!isEmptyObject(funcOptions.pageLifetimes)) {
-      _sameFuncOptionsHandle(finalOptionsForComponent.methods, funcOptions.pageLifetimes);
-    }
-  } else {
-    // 组件时
-    if (!isEmptyObject(funcOptions.pageLifetimes)) {
-      _sameFuncOptionsHandle(finalOptionsForComponent.pageLifetimes, funcOptions.pageLifetimes);
-    }
-  }
-  if (funcOptions.lifetimes) _sameFuncOptionsHandle(finalOptionsForComponent.lifetimes, funcOptions.lifetimes);
-
-  if (funcOptions.watch) _sameFuncOptionsHandle(finalOptionsForComponent.watch, funcOptions.watch);
-}

package/src/api/DefineComponent/normalizeOptions/watchHandler/getPathsValue.ts

@@ -1,31 +0,0 @@
-/**
- * 获取指定paths的值
- * @param obj  - 数据对象
- * @param paths - 支持多字段(用`,`分开) 例如 'obj.xxx,a,b.**'
- * @returns unknown[] 每项对应paths每项的值
- */
-export function getPathsValue(obj: object, paths: string) {
-  const valueList: unknown[] = [];
-
-  // ['obj.xxx','a','b.**'].forEach
-  paths.split(",").forEach(path => {
-    // path : 'obj.xxx' | 'a' | 'b.**'
-    if (path.includes(".**")) {
-      // "b.**" => 'b'
-      path = path.slice(0, -3);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const value = path.split(".").reduce((pre: any, path) => {
-      // pre有可能为undefined|null,比如obj是未初始化的计算属性(undefined),还有可能是properties的对象类型(默认为null)
-      try {
-        return pre[path];
-      } catch {
-        return undefined;
-      }
-    }, obj);
-
-    valueList.push(value);
-  });
-
-  return valueList;
-}

package/src/api/DefineComponent/normalizeOptions/watchHandler/getPropertiesValue.ts

@@ -1,51 +0,0 @@
-import type {
-  PropertiesConstraint,
-  PropertiesTypes,
-  RequiredSingle,
-  RequiredUnion,
-} from "../../../RootComponent/Properties/PropertiesConstraint";
-
-type PropertiesDefaultValue = "" | 0 | [] | null | false;
-/* istanbul ignore next */
-function getRequiredSingleValue(
-  PropType: RequiredSingle,
-): PropertiesDefaultValue {
-  switch (PropType) {
-    case String:
-      return "";
-    case Number:
-      return 0;
-    case Array:
-      return [];
-    case Object:
-      return null;
-    case Boolean:
-      return false;
-    default:
-      /* istanbul ignore next */
-      throw Error(
-        "properties字段类型只能为 String | Number | Array | Object | Boolean ",
-      );
-  }
-}
-function IsRequiredSingle(config: PropertiesTypes): config is RequiredSingle {
-  return config instanceof Function;
-}
-function IsRequiredUnion(config: PropertiesTypes): config is RequiredUnion {
-  return !Reflect.has(config, "value");
-}
-export function getPropertiesValue(propertiesOpt: PropertiesConstraint): object {
-  const result: Record<string, unknown> = {};
-  for (const key in propertiesOpt) {
-    const config = propertiesOpt[key];
-    if (IsRequiredSingle(config)) {
-      result[key] = getRequiredSingleValue(config);
-    } else if (IsRequiredUnion(config)) {
-      result[key] = getRequiredSingleValue(config.type);
-    } else {
-      result[key] = config.value;
-    }
-  }
-
-  return result;
-}

package/src/api/DefineComponent/normalizeOptions/watchHandler/hasComputedPath.ts

@@ -1,9 +0,0 @@
-export function hasComputedPath(watchPath: string, computedKeys: string[]) {
-  return watchPath.split(",").some((path) => {
-    const firstPath = path.split(".")[0];
-    if (computedKeys.includes(firstPath)) {
-      return true;
-    }
-    return false;
-  });
-}

package/src/api/DefineComponent/normalizeOptions/watchHandler/index.ts

@@ -1,78 +0,0 @@
-import type { Func } from "hry-types/src/Misc/Func";
-import { deepClone, deepEqual, isEmptyObject, nonNullable } from "../../../../utils/_utils";
-import type { Instance } from "../../../RootComponent/Instance/RootComponentInstance";
-import type { FinalOptionsOfComponent, WatchOldValue } from "..";
-import { getPathsValue } from "./getPathsValue";
-import { getPropertiesValue } from "./getPropertiesValue";
-import { hasComputedPath } from "./hasComputedPath";
-
-// 初始化watch监控字段的旧值对象,排除有计算属性的字段。
-function initWatchOldValuesWithoutComputed(
-  data: FinalOptionsOfComponent["data"],
-  watchConfig: object,
-  computedKeys: string[],
-): WatchOldValue {
-  const watchOldValue: WatchOldValue = {};
-  for (const path in watchConfig) {
-    // 有计算属性的路径,跳过会在计算属性初始化后赋值
-    if (hasComputedPath(path, computedKeys)) continue;
-    watchOldValue[path] = deepClone(getPathsValue(data, path));
-  }
-
-  return watchOldValue;
-}
-function observerHandler(
-  this: Instance,
-  key: string,
-  originObserversHandle: Func | undefined,
-  watchHadle: Func,
-  ...newValue: unknown[]
-) {
-  // 先调用原生observers的回调函数,再调用watch的回调函数。因为watch的回调函数可能会用到原生observers回调函数中更新的数据。
-  originObserversHandle?.call(this, ...newValue);
-  const watchOldValue = nonNullable(this.data.__watchOldValue__);
-  const oldValue = watchOldValue[key];
-  if (deepEqual(newValue, oldValue)) return;
-  watchOldValue[key] = deepClone(newValue);
-  watchHadle.call(this, ...newValue, ...oldValue);
-}
-
-/**
- * 把watch配置转换成observers配置的形式,并在回调函数中调用watch的回调函数。
- * 小程序的observers是通过监控setData字段,来触发的,不会比较值的变化,小程序底层代码可以监控到properties变化时的setData动作.
- * watch字段的目的是数据变化时才触发回调函数,但由于实例中无法通过setData的调用来监听到properties字段变化,所以watch字段的实现方式是通过在observers回调函数中比较新旧值来实现的。
- * 还要在组件实例上维护一个__watchOldValue__对象来存储watch监控字段的旧值，以便在回调函数中进行比较。
- * @param finalOptionsForComponent
- */
-export function handleWatchConfig(
-  finalOptionsForComponent: FinalOptionsOfComponent,
-) {
-  const { observers: observersConfig, watch: watchConfig, data, properties, computed: computedConfig } =
-    finalOptionsForComponent;
-  if (!isEmptyObject(watchConfig)) {
-    const rawPropertiesValue = getPropertiesValue(properties);
-    const computedKeys = Object.keys(computedConfig);
-
-    data.__watchOldValue__ = initWatchOldValuesWithoutComputed(
-      { ...data, ...rawPropertiesValue },
-      watchConfig,
-      computedKeys,
-    );
-    for (const key in watchConfig) {
-      const watchHadle = watchConfig[key];
-      const originObserversHandle = observersConfig[key] as Func | undefined;
-      // 在监控多个数据时,参数是多个值
-      observersConfig[key] = function(this: Instance, ...values: unknown[]) {
-        // 计算属性初始化完成时直接调用。
-        if (this.data.__computedInited__) {
-          observerHandler.call(this, key, originObserversHandle, watchHadle, ...values);
-        } else {
-          // 计算属性未初始化完成时,先把watch的回调函数注册到实例上,等计算属性初始化完成时再调用。因为计算属性初始化完成时会把data中的值setData一次,会触发observers回调函数,所以在这里注册watch的回调函数,就能保证计算属性初始化完成后能正确调用watch的回调函数。
-          (this.data.__oberverHandler__ ||= []).push(
-            observerHandler.bind(this, key, originObserversHandle, watchHadle, ...values),
-          );
-        }
-      };
-    }
-  }
-}

package/src/api/DefineComponent/returnType/ComponentDoc.ts

@@ -1,25 +0,0 @@
-type PrefixKey = `${string}_${string}`;
-
-type _ComponentDoc = {
-  properties?: Record<PrefixKey, unknown>;
-  events?: Record<PrefixKey, unknown>;
-};
-
-type Error = "{ properties?: Record<PrefixKey, any>; events?: Record<PrefixKey, any>;}";
-
-type _Validator<O> = keyof O extends keyof _ComponentDoc
-  // @ts-ignore 要求ComponentDoc有前缀
-  ? keyof (O["properties"] & O["events"]) extends PrefixKey ? _ComponentDoc
-  : Error
-  : Error;
-
-/**
- * 组件文档类型
- * ```ts
- * type XxxDoc = {
- *  properties?: Record<PrefixKey, unknown>;
- *  events?: Record<PrefixKey, unknown>;
-};
- * ```
- */
-export type ComponentDoc<O extends _Validator<O> = _ComponentDoc> = O;