annil 1.17.0 → 1.18.0

package/src/api/DefineComponent/index.ts

@@ -1,58 +0,0 @@
-import type { IfExtends } from "hry-types/src/Any/IfExtends";
-
-import type { RootComponentDefinition, RootComponentDefinitionRuntime } from "../RootComponent/returnType";
-import type { SubComponentDefinition, SubComponentDefinitionRuntime } from "../SubComponent/returnType";
-import type { NameOrPathOption } from "./NameOrPath/NameOrPathOption";
-import { normalizeOptions } from "./normalizeOptions";
-import type { GenerateComponentDoc } from "./returnType/GenerateComponentDoc";
-import type { GeneratePageDoc } from "./returnType/GeneratePageDoc";
-import type { RootComponentOption } from "./RootComponent/RootComponentOption";
-import type { SubComponentsOption } from "./SubComponents/SubComponentsOption";
-export type Path = `/${string}`;
-
-type Options<
-  TRootComponentDefinition extends RootComponentDefinition,
-  TSubComponentDefinitionList extends SubComponentDefinition[],
-  TName extends string,
-  TPath extends Path,
-> =
-  & NameOrPathOption<TName, TPath, NonNullable<TRootComponentDefinition["isPage"]>>
-  & RootComponentOption<TRootComponentDefinition>
-  & SubComponentsOption<TSubComponentDefinitionList>;
-
-type Constructor = <
-  TRootComponentDefinition extends RootComponentDefinition = {},
-  TSubComponentDefinitionList extends SubComponentDefinition[] = [],
-  TName extends string = "",
-  TPath extends Path = "/",
->(
-  options: Options<TRootComponentDefinition, TSubComponentDefinitionList, TName, TPath>,
-) => //  根据是否传入name字段(当isPage不为true时,类型约束name不为空字符串)来区分生成页面文档还是组件文档。
-IfExtends<
-  "",
-  TName,
-  GeneratePageDoc<TRootComponentDefinition, TPath>,
-  GenerateComponentDoc<TRootComponentDefinition, TName, TSubComponentDefinitionList>
->;
-/**
- * DefineComponentOptionRuntime是DefineComponent的options参数的运行时类型。
- */
-export type DefineComponentOptionRuntime = {
-  name?: string;
-  path?: string;
-  rootComponent?: RootComponentDefinitionRuntime;
-  subComponents?: SubComponentDefinitionRuntime[];
-};
-
-/**
- * DefineComponent是构建组件的核心API,所有组件(页面组件和自定义组件)都通过它来构建的。
- * 它返回的类型可能是页面文档(`PageDoc`)或者自定义组件文档(`ComponentDoc`),具体取决于传入rootComponent中isPage的值。
- * 它的作用是把根组件定义(`RootComponentDefinition`)和子组件定义(`SubComponentDefinition`)整合成原生`Component`的选项配置,最终通过原生`Component`来构建组件。
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- 返回类型由Constructor定义,实现无需。
-export const DefineComponent: Constructor = function(options): any {
-  Component(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Options泛型中properties字段类型与WechatMiniprogram.Component.Constructor中的properties字段类型不兼容,但运行时是兼容的,所以这里使用any。
-    normalizeOptions(options as DefineComponentOptionRuntime) as any,
-  );
-};

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

@@ -1,29 +0,0 @@
-import type { RootComponentDefinitionRuntime } from "../../RootComponent/returnType";
-import type { SubComponentDefinitionRuntime } from "../../SubComponent/returnType";
-
-export function __throttleDebounce__FieldCheck(
-  config: RootComponentDefinitionRuntime | SubComponentDefinitionRuntime[],
-) {
-  if (Array.isArray(config)) {
-    for (const subComponent of config) {
-      __throttleDebounce__FieldCheck(subComponent);
-    }
-  } else {
-    const dataKeys: string[] = [];
-    if (config.data) {
-      dataKeys.push(...Object.keys(config.data));
-    }
-    if (config.computed) {
-      dataKeys.push(...Object.keys(config.computed));
-    }
-    if (config.properties) {
-      dataKeys.push(...Object.keys(config.properties));
-    }
-    if (config.store) {
-      dataKeys.push(...Object.keys(config.store));
-    }
-    if (dataKeys.includes("__throttleDebounce__")) {
-      throw Error(`__throttleDebounce__字段已被内部字段占用`);
-    }
-  }
-}

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

@@ -1,55 +0,0 @@
-import type {
-  CustomEventConstraint,
-  CustomEvents,
-  FullCustomEvents,
-} from "../../RootComponent/CustomEvents/CustomEventConstraint";
-import type { Instance } from "../../RootComponent/Instance/RootComponentInstance";
-import type { FinalOptionsOfComponent, ThrottleDebounce } from ".";
-function getThrottleDebounceConfig(
-  methodsName: string,
-  customEventOptions: FullCustomEvents,
-  __throttleDebounce__: ThrottleDebounce,
-) {
-  const { debounce, throttle } = customEventOptions;
-
-  if (debounce) {
-    __throttleDebounce__.debounce ||= {};
-    __throttleDebounce__.debounce[methodsName] = debounce;
-  } else if (throttle) {
-    __throttleDebounce__.throttle ||= {};
-    __throttleDebounce__.throttle[methodsName] = throttle;
-  }
-}
-
-// 类型守卫
-function IsFullCustomEvents(
-  customEventOptions: CustomEvents,
-): customEventOptions is FullCustomEvents {
-  return Object.prototype.toString.call(customEventOptions) === "[object Object]";
-}
-/**
- * 把customEvents字段配置变成函数放入到componentOptions.methods中
- */
-export function customEventsHandle(
-  finalOptions: FinalOptionsOfComponent,
-  customEventsConfig: CustomEventConstraint,
-) {
-  const methods = finalOptions.methods;
-  const data = finalOptions.data;
-
-  for (const key in customEventsConfig) {
-    const customEventOptions = customEventsConfig[key];
-    if (IsFullCustomEvents(customEventOptions)) {
-      methods[key] = function(this: Instance, detail: unknown) {
-        this.triggerEvent(key, detail, customEventOptions.options);
-      };
-      data.__throttleDebounce__ ||= {};
-      // 全配置允许设置防抖和节流,在这里保留配置到data.__throttleDebounce__中,以便后续使用
-      getThrottleDebounceConfig(key, customEventOptions, data.__throttleDebounce__);
-    } else {
-      methods[key] = function(this: Instance, detail: unknown) {
-        this.triggerEvent(key, detail);
-      };
-    }
-  }
-}

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

@@ -1,33 +0,0 @@
-import { isEmptyObject } from "../../../utils/isEmptyObject";
-
-import type { RootComponentDefinitionRuntime } from "../../RootComponent/returnType";
-import type { FinalOptionsOfComponent, SameFuncOptions } from ".";
-import { __throttleDebounce__FieldCheck } from "./__throttleDebounce__FieldCheck";
-import { customEventsHandle } from "./customEventsHandle";
-import { otherFieldsHandle } from "./otherFieldsHandle";
-import { sameFuncFieldsCollect } from "./sameFuncFieldsCollect";
-
-/**
- * 收集 rootComponentOptions 配置到 finalOptions 和 funcOptions 中
- * @param finalOptions - 收集配置对象`
- * @param rootComponent - 被收集的源配置对象
- * @param funcOptions  - 收集特殊配置对象字段
- */
-export function handleRootComponent(
-  finalOptions: FinalOptionsOfComponent,
-  rootComponent: RootComponentDefinitionRuntime | undefined,
-  funcOptions: SameFuncOptions,
-) {
-  if (rootComponent && !isEmptyObject(rootComponent)) {
-    // 验证配置中是否有内部字段__throttleDebounce__,有则报错,因为在rootComponentOptionHandle中会加入__throttleDebounce__字段到data中
-    __throttleDebounce__FieldCheck(rootComponent);
-    // 自定义事件处理时,如果配置了防抖节流,则需要在data.__throttleDebounce__保留配置信息,以便后续使用
-    if (rootComponent.customEvents) customEventsHandle(finalOptions, rootComponent.customEvents);
-    delete rootComponent.customEvents;
-    if (rootComponent.events) Object.assign(finalOptions.methods, rootComponent.events);
-    delete rootComponent.events;
-    sameFuncFieldsCollect(rootComponent, funcOptions);
-
-    otherFieldsHandle(finalOptions, rootComponent);
-  }
-}

package/src/api/DefineComponent/normalizeOptions/handleStore/disposeStore.ts

@@ -1,10 +0,0 @@
-import type { Instance } from "../../../RootComponent/Instance/RootComponentInstance";
-
-export function disposeStore(this: Instance) {
-  const { disposer } = this;
-  for (const key in disposer) {
-    disposer[key]();
-  }
-  // 清除disposer
-  this.disposer = {};
-}

package/src/api/DefineComponent/normalizeOptions/handleStore/initStore.ts

@@ -1,9 +0,0 @@
-import type { Instance } from "../../../RootComponent/Instance/RootComponentInstance";
-import type { FinalOptionsOfComponent } from "..";
-import { reactionRegister } from "./reactionRegister";
-export function initStore(storeConfig: FinalOptionsOfComponent["store"] | undefined) {
-  return function(this: Instance) {
-    if (!storeConfig) return;
-    reactionRegister.call(this, storeConfig);
-  };
-}

package/src/api/DefineComponent/normalizeOptions/handleStore/reactionRegister.ts

@@ -1,70 +0,0 @@
-import type mobx from "mobx";
-import type { Instance } from "../../../RootComponent/Instance/RootComponentInstance";
-import type { StoreConstraint } from "../../../RootComponent/Store/StoreConstraint";
-
-/**
- * 为store字段注册reaction,以实现响应式更新。
- * 注意:如果getter函数返回undefined,则不会注册reaction,该字段将不可响应式,但不报错(有警告)。如果getter函数没有依赖任何响应式数据,则不会注册reaction,该字段将不可响应式,并抛出错误。
- * @param this
- * @param storeConfig
- */
-export function reactionRegister(this: Instance, storeConfig: StoreConstraint) {
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const { comparer, getDependencyTree, reaction, toJS } = require("mobx") as typeof mobx;
-  // 1. 清理旧的reaction,避免重复注册(组件detached),虽然在detached时加入了清理reaction的逻辑,但在某些极端情况下可能无法触发(如组件未调用detached周期,就又运行了attached周期),因此在这里先清理一次,确保不会重复注册。
-  if (this.disposer) {
-    for (const key of Object.keys(this.disposer)) {
-      this.disposer[key]();
-    }
-  }
-  this.disposer = {};
-  const pendingSetData: Record<string, unknown> = {};
-
-  for (const key of Object.keys(storeConfig)) {
-    const getter = storeConfig[key];
-
-    // 1. 临时 reaction：只用来检测依赖
-    let hasObservableDependency = false;
-    let firstRunValue: unknown;
-
-    const tempDisposer = reaction(
-      () => {
-        const value = getter(this.data);
-        firstRunValue = value; // 顺便获取初始值
-        return value;
-      },
-      () => void 0, // 空回调，零副作用
-      { fireImmediately: true },
-    );
-
-    // 2. 检查依赖
-    const deps = getDependencyTree(tempDisposer).dependencies ?? [];
-    hasObservableDependency = deps.length > 0;
-    // 3. 清理临时 reaction
-    tempDisposer();
-
-    // 4. 验证
-    if (firstRunValue === undefined) {
-      console.warn(`store字段 ${key} 的getter函数返回了undefined，该字段将不会被注册为响应式字段。`);
-      continue;
-    }
-
-    if (!hasObservableDependency) {
-      throw new Error(`store字段 ${key} 的getter函数没有依赖任何响应式数据。`);
-    }
-
-    // 5. 正式绑定
-    const disposer = reaction(
-      () => getter(this.data),
-      (value: unknown) => {
-        this.setData({ [key]: toJS(value) });
-      },
-      { equals: comparer.structural },
-    );
-
-    pendingSetData[key] = toJS(firstRunValue);
-    this.disposer[key] = disposer;
-  }
-
-  this.setData(pendingSetData);
-}

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

@@ -1,23 +0,0 @@
-import type { SubComponentDefinitionRuntime } from "../../SubComponent/returnType";
-import type { FinalOptionsOfComponent, SameFuncOptions } from ".";
-import { __throttleDebounce__FieldCheck } from "./__throttleDebounce__FieldCheck";
-import { otherFieldsHandle } from "./otherFieldsHandle";
-import { sameFuncFieldsCollect } from "./sameFuncFieldsCollect";
-
-export function handleSubComponents(
-  componentOptions: FinalOptionsOfComponent,
-  subComponents: SubComponentDefinitionRuntime[] | undefined,
-  funcOptions: SameFuncOptions,
-) {
-  if (subComponents && subComponents.length !== 0) {
-    // 验证配置中是否有内部字段__throttleDebounce__,有则报错,因为在rootComponentOptionHandle中会加入__throttleDebounce__字段到data中
-    __throttleDebounce__FieldCheck(subComponents);
-    subComponents.forEach((subOption) => {
-      if (subOption.events) Object.assign(componentOptions.methods, subOption.events);
-
-      sameFuncFieldsCollect(subOption, funcOptions);
-
-      otherFieldsHandle(componentOptions, subOption);
-    });
-  }
-}

package/src/api/DefineComponent/normalizeOptions/hijackHandle/addDetachedData.ts

@@ -1,10 +0,0 @@
-import type { Instance } from "../../../RootComponent/Instance/RootComponentInstance";
-
-export function addDetachedData(this: Instance) {
-  // 如果 attached字段被占用,就不添加了
-  if (this.data.attached !== undefined) return;
-  this.setData({
-    // @ts-ignore
-    attached: true,
-  });
-}

package/src/api/DefineComponent/normalizeOptions/hijackHandle/hijack.ts

@@ -1,26 +0,0 @@
-import type { Func } from "hry-types/src/Misc/Func";
-import type { FinalOptionsOfComponent } from "..";
-
-/**
- * 劫持指定配置字段,在原有配置前执行指定函数
- */
-export function hijack<T extends FinalOptionsOfComponent[keyof FinalOptionsOfComponent]>(
-  config: T,
-  field: keyof T,
-  before: Func[],
-  after: Func[] = [],
-) {
-  // @ts-ignore 隐式索引
-  const originalFunc: Func | undefined = config[field];
-
-  // @ts-ignore 隐式索引
-  config[field] = function(...args: unknown[]) {
-    before.forEach(func => func.call(this, ...args));
-
-    if (originalFunc) originalFunc.apply(this, args);
-
-    after.forEach(func => func.call(this, ...args));
-  };
-
-  return;
-}

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

@@ -1,57 +0,0 @@
-import type { Instance } from "../../../RootComponent/Instance/RootComponentInstance";
-import type { FinalOptionsOfComponent } from "..";
-import { disposeStore } from "../handleStore/disposeStore";
-import { initStore } from "../handleStore/initStore";
-import { initComputed } from "../initComputed";
-import { computedUpdater } from "../initComputed/computedUpdater";
-import { addDetachedData } from "./addDetachedData";
-import { hijack } from "./hijack";
-import { isPageCheck } from "./isPageCheck";
-// import { loadReceivedDataHandle } from "./loadReceivedDataHandle";
-import { onLoadReceivedDataHandle } from "./onLoadReceivedDataHandle";
-import { pagePathCheck } from "./pagePathCheck";
-
-export function hijackHandle(
-  finalOptionsForComponent: FinalOptionsOfComponent,
-  isPage: boolean | undefined,
-  path: string | undefined,
-) {
-  // if (finalOptionsForComponent.isPage) {
-  //   hijack(finalOptionsForComponent.pageLifetimes, "load", [loadReceivedDataHandle]);
-  // }
-
-  hijack(finalOptionsForComponent.methods, "onLoad", [onLoadReceivedDataHandle]);
-  hijack(finalOptionsForComponent.observers, "**", [
-    computedUpdater,
-  ]);
-
-  hijack(
-    finalOptionsForComponent.lifetimes,
-    "attached",
-    [
-      // 验证isPage字段是否配置正确
-      isPageCheck(isPage),
-      // 验证页面的Path字段是否配置正确
-      pagePathCheck(path),
-      initStore(finalOptionsForComponent.store),
-      // 计算属性的初始化应该在store初始化之后,因为计算属性可能依赖store。
-      initComputed(finalOptionsForComponent.computed, finalOptionsForComponent.watch),
-      // 在初始化计算属性后,再让构建组件时的observers的回调函数被调用.避免回调函数中用到了计算属性的值时报错。
-      function(this: Instance) {
-        const observerhandlers = this.data.__oberverHandler__;
-        if (observerhandlers) {
-          for (const observerhandler of observerhandlers) {
-            observerhandler.call(this);
-          }
-          Reflect.deleteProperty(this.data, "__oberverHandler__");
-        }
-      },
-    ],
-    [addDetachedData],
-  );
-  hijack(
-    finalOptionsForComponent.lifetimes,
-    "detached",
-    [disposeStore],
-  );
-}

package/src/api/DefineComponent/normalizeOptions/hijackHandle/isPageCheck.ts

@@ -1,22 +0,0 @@
-import type { Instance, PageInstance } from "../../../RootComponent/Instance/RootComponentInstance";
-
-/**
- * 劫持attached,根据this.route做判断 isPage值是否正确
- */
-export function isPageCheck(isPage: boolean | undefined) {
-  return function(this: Instance) {
-    const route = (this as PageInstance).route as string | undefined;
-    if (route && isPage !== true) {
-      // 页面isPage值错误
-      throw Error(
-        `页面 /${route} 中, RootComponent构建页面时,isPage字段值应为 true`,
-      );
-    }
-    if (!route && isPage !== false && isPage !== undefined) {
-      // 组件写了isPage = true
-      throw Error(
-        `组件 ${this.is} 中  RootComponent构建组件时,可不写isPage字段或值为 false`,
-      );
-    }
-  };
-}

package/src/api/DefineComponent/normalizeOptions/hijackHandle/loadReceivedDataHandle.ts

@@ -1,25 +0,0 @@
-// /**
-//  * 针对通过 navigateTo传过来的数据对组件load周期传入数据解析
-//  * @param option - option中的url是拼接了encodeURIComponent转码的data对象的,key为INNERMARKER.url
-//  */
-
-// import { INNERMARKER } from "../../../../utils/InnerMarker";
-// import type { PageInstance } from "../../../RootComponent/Instance/RootComponentInstance";
-
-// /* istanbul ignore next miniprogram-simulate(当前版本 1.6.1) 无法测试load */
-// export function loadReceivedDataHandle(
-//   this: PageInstance,
-//   option: Record<typeof INNERMARKER.url, string>,
-// ) {
-//   const innerData: string | undefined = option[INNERMARKER.url];
-//   // 未使用自定义的navigateTo
-//   if (innerData === undefined) return;
-//   // 使用navigateTo API
-//   const decodeOption = JSON.parse(decodeURIComponent(innerData));
-
-//   for (const key in decodeOption) {
-//     option[key] = decodeOption[key];
-//   }
-//   // 给onLoad劫持函数一个标记,判断在新框架下已经被解析过了
-//   option[INNERMARKER.url] = INNERMARKER.url;
-// }

package/src/api/DefineComponent/normalizeOptions/hijackHandle/onLoadReceivedDataHandle.ts

@@ -1,33 +0,0 @@
-/**
- * 原生Component会对传入的对象字段匹配的properties字段setData赋值。不符合字段或Page时不会赋值。
- * 此函数为给实例setData赋值,默认传递值与properties相符(ts类型安全)。
- * @param option - 传入onLoad的参数 有以下两种可能
- * 1. 使用wx.navigateTo传值的。这种情况无内置字段 option[INNERMARKER.url] 等于 undefined
- * 2. 使用插件提供的navigateTo传值。这种情况 INNERMARKER.url被load周期劫持函数解码后赋值INNERMARKER.url字段为本身,即option[INNERMARKER.url] 等于 INNERMARKER.url
- */
-
-import { INNERMARKER } from "../../../../utils/InnerMarker";
-import type { PageInstance } from "../../../RootComponent/Instance/RootComponentInstance";
-
-/* istanbul ignore next miniprogram-simulate(当前版本 1.6.1) 无法测试页面生命周期 */
-export function onLoadReceivedDataHandle(
-  this: PageInstance,
-  option: Record<typeof INNERMARKER.url, string>,
-) {
-  const innerData: string | undefined = option[INNERMARKER.url];
-
-  // 情况1为undefined,2为INNERMARKER.url有值但不是本身,说明是老框架。3所以innerData等于 INNERMARKER.url即有组件配置了load(新框架在pageLifetimes.load中提前解析了)
-  if (innerData === undefined) return;
-  if (innerData !== INNERMARKER.url) {
-    // 需要情况2 需要解析
-    const decodeOption = JSON.parse(decodeURIComponent(innerData));
-    for (const key in decodeOption) {
-      option[key] = decodeOption[key];
-    }
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-  delete option[INNERMARKER.url];
-
-  this.setData(option);
-}

package/src/api/DefineComponent/normalizeOptions/hijackHandle/pagePathCheck.ts

@@ -1,9 +0,0 @@
-import type { Instance } from "../../../RootComponent/Instance/RootComponentInstance";
-
-export function pagePathCheck(path?: string) {
-  return function(this: Instance) {
-    if (path && `/${this.is}` !== path) {
-      throw new Error(`页面路径错误,应为 /${this.is}`);
-    }
-  };
-}

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

@@ -1,143 +0,0 @@
-import type { Func } from "hry-types/src/Misc/_api";
-import { BBeforeCreate } from "../../../behaviors/BbeforeCreated";
-import { BthrottleDebounce } from "../../../behaviors/BthrottleDebounce";
-import { applyDebounceAndThrottle } from "../../../utils/applyDebounceAndThrottle";
-import { instanceConfig } from "../../InstanceInject/instanceConfig";
-import type { ComputedConstraint } from "../../RootComponent/Computed/ComputedConstraint";
-import type { DataConstraint } from "../../RootComponent/Data/DataConstraint";
-import type { LifetimesConstraint } from "../../RootComponent/Lifetimes/LifetimesConstraint";
-import type { MethodsConstraint } from "../../RootComponent/Methods/MethodsConstraint";
-import type { PageLifetimesOption } from "../../RootComponent/PageLifetimes/PageLifetimesOption";
-import type { PropertiesConstraint } from "../../RootComponent/Properties/PropertiesConstraint";
-import type { StoreConstraint } from "../../RootComponent/Store/StoreConstraint";
-import type { DefineComponentOptionRuntime } from "..";
-import { handleRootComponent } from "./handleRootComponent";
-import { handleSubComponents } from "./handleSubComponents";
-import { hijackHandle } from "./hijackHandle";
-import type { ComputedCache } from "./initComputed/initComputedAndGetCache";
-import { injectInfoHandler } from "./injectInfoHandler";
-import { InternalFieldProtection } from "./internalFieldProtection";
-import { sameFuncOptionsHandle } from "./sameFuncOptionsHandle";
-import { handleWatchConfig } from "./watchHandler";
-// 因为watch字段可能有多个变量,所以在这里定义的value是一个数组
-export type WatchOldValue = Record<string, unknown[]>;
-export type ThrottleDebounce = Partial<Record<"throttle" | "debounce", Record<string, number>>>;
-export type OptionsInnerFields = {
-  data: {
-    __storeInited__?: boolean;
-    // 在attach周期结束后,为data.attached赋值为true
-    attached?: boolean;
-    // // 为data.attached赋值为true时会触发Observers["**"]的回调函数,进而运行computedUpdater,所以要设置一个标志位来避免触发computedUpdater。因为这是无意义的。
-    __computedInited__?: boolean;
-    __oberverHandler__?: Func[];
-    __computedCache__?: ComputedCache;
-    __watchOldValue__?: WatchOldValue;
-    __throttleDebounce__?: ThrottleDebounce;
-  };
-};
-
-/**
- * 临时的函数配置项
- * 把根组件与子组件中配置类型为函数的相同字段配置收集在一起(数组)
- */
-export type SameFuncOptions = Record<"pageLifetimes" | "lifetimes" | "watch" | "observers", Record<string, Func[]>>;
-
-/**
- * 最终传入原生Component的配置项
- */
-export type FinalOptionsOfComponent = {
-  data: DataConstraint & OptionsInnerFields["data"];
-  observers: Record<string, Func>;
-  behaviors: string[];
-  methods: MethodsConstraint;
-  externalClasses: string[];
-  pageLifetimes: PageLifetimesOption<false, object>["pageLifetimes"] & {};
-  isPage: boolean;
-  options: WechatMiniprogram.Component.ComponentOptions;
-  properties: PropertiesConstraint;
-  store?: StoreConstraint;
-  computed: ComputedConstraint;
-  watch: Record<string, Func>;
-  lifetimes: LifetimesConstraint;
-};
-
-/**
- * 把DefineComponentOption转化为原生Component API支持的配置
- * @param defineComponentOption
- * @returns  返回符合原生Component API配置
- */
-export function normalizeOptions(
-  defineComponentOption: DefineComponentOptionRuntime,
-): FinalOptionsOfComponent {
-  const { rootComponent, subComponents, path } = defineComponentOption;
-  const isPage = rootComponent?.isPage ?? false;
-  const finalOptionsForComponent: FinalOptionsOfComponent = {
-    observers: {},
-    data: {},
-    methods: {},
-    behaviors: [BthrottleDebounce],
-    externalClasses: [],
-    pageLifetimes: {},
-    isPage,
-    properties: {},
-    computed: {},
-    watch: {},
-    lifetimes: {},
-    options: {},
-  };
-  // 处理注入的实例配置项
-  injectInfoHandler(finalOptionsForComponent, instanceConfig.injectInfo);
-  /**
-   * 为了更高的效率,在处理rootComponentOption和subComponentsOption数据时,把相同字段配置(pageLifetimes，lifetimes,watch,observers)收集到funcOptions中。
-   * 后续再一起处理这些字段,整合进finalOptionsForComponent配置中。即funcConfig是一个临时中介对象。
-   */
-  const sameFuncOptions: SameFuncOptions = {
-    pageLifetimes: {},
-    lifetimes: {},
-    watch: {},
-    observers: {},
-  };
-
-  handleRootComponent(finalOptionsForComponent, rootComponent, sameFuncOptions);
-
-  handleSubComponents(finalOptionsForComponent, subComponents, sameFuncOptions);
-
-  sameFuncOptionsHandle(finalOptionsForComponent, isPage, sameFuncOptions);
-
-  // 配置与内部字段冲突验证
-  InternalFieldProtection(finalOptionsForComponent);
-
-  // 页面时删除预设的虚拟组件字段
-  if (isPage && finalOptionsForComponent.options) {
-    Reflect.deleteProperty(finalOptionsForComponent.options, "virtualHost");
-  }
-
-  // 处理debounce和throttle前缀的方法(事件)配置
-  applyDebounceAndThrottle(finalOptionsForComponent.methods);
-
-  // 处理watch配置,注意的是 oldValue中的计算属性初始赋值在计算属性初始化完毕后,即计算属性初始化后,再变化时才会被watch到。
-  handleWatchConfig(finalOptionsForComponent);
-
-  // BBeforeCreate在最后面,让BeforeCreate生命周期运行在最终建立组件时。用于测试。
-  finalOptionsForComponent.behaviors.push(BBeforeCreate);
-
-  // 劫持函数的处理
-  hijackHandle(finalOptionsForComponent, isPage, path);
-
-  return finalOptionsForComponent;
-}
-
-/**
- * computed设计逻辑
- * 在之前的设计中,计算属性的初始化发生在beforeCreate阶段,通过通过监控observers["**"]来触发计算属性的更新。
- * 有一些问题如下:
- *   1. 如果依赖属性是properties的情况下(实际上大多数时候都是)初始化时的数据是无意义的,因为beforeCreate阶段properties数据还没传入。
- * 如果想节省调用(可减少组件渲染时间),应该在properties数据传入后再初始化计算属性,且让初始化时发生的setData不引起watch和observers的响应。什么时候properties已经传入呢?那就是挂载阶段,可是小程序只有attached钩子,只能通过observers["**"]的第一次触发模拟attach周期(只要传入了properties字段定义的属性那么,observers.**就好比attach周期了,会在attached周期之前触发）。需要注意的是如果没有定义properties字段或者传入的属性不在properties中,那么observers["**"]就不会在attached之前触发,所以在attached阶段要做一次检测,如果没有初始化计算属性,就在这个周期中初始化计算属性。
- * 在计算属性初始化函数中,要检测this.data.__computedCache__是否存在,如果存在就表示已经初始化过了,否则初始化计算属性,并把__initializing__设置为true。这样就可以避免在初始化计算属性时用到setData时,引起watch和observers的触发(watch的回调在执行前判断__initializing__,如果为false才执行)。
- * 还有一个问题就是watch的oldValue,在watch的初始化函数中只针对不包含计算属性的path进行赋值,这样不影响非计算属性的监控。在计算属性初始化完毕后,再对包含计算属性的path进行赋值。这样oldValue的值才是正确的。这样可避免在observers.path中使用计算属性而报错。
- *
- * 整体实现思路:
- * 1. 劫持observers["**"]事件,在observers["**"]触发时,看data.__computedCache__是否存在,如果不存在,就初始化计算属性。并把data.__computedCache__赋值为true。
- * 2. 劫持attached事件,在attached阶段,如果data.__computedCache__不存在,就初始化计算属性。并把data.__computedCache__赋值为true。
- * 这样j
- */