annil 1.14.0 → 1.16.0

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

@@ -1,25 +1,25 @@
-/**
- * 针对通过 navigateTo传过来的数据对组件load周期传入数据解析
- * @param option - option中的url是拼接了encodeURIComponent转码的data对象的,key为INNERMARKER.url
- */
+// /**
+//  * 针对通过 navigateTo传过来的数据对组件load周期传入数据解析
+//  * @param option - option中的url是拼接了encodeURIComponent转码的data对象的,key为INNERMARKER.url
+//  */
 
-import { INNERMARKER } from "../../../../utils/InnerMarker";
-import type { PageInstance } from "../../../RootComponent/Instance/RootComponentInstance";
+// 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));
+// /* 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;
-}
+//   for (const key in decodeOption) {
+//     option[key] = decodeOption[key];
+//   }
+//   // 给onLoad劫持函数一个标记,判断在新框架下已经被解析过了
+//   option[INNERMARKER.url] = INNERMARKER.url;
+// }

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

@@ -18,7 +18,7 @@ import type { ComputedCache } from "./initComputed/initComputedAndGetCache";
 import { injectInfoHandler } from "./injectInfoHandler";
 import { InternalFieldProtection } from "./internalFieldProtection";
 import { sameFuncOptionsHandle } from "./sameFuncOptionsHandle";
-import { watchHandler } from "./watchHandler";
+import { handleWatchConfig } from "./watchHandler";
 // 因为watch字段可能有多个变量,所以在这里定义的value是一个数组
 export type WatchOldValue = Record<string, unknown[]>;
 export type ThrottleDebounce = Partial<Record<"throttle" | "debounce", Record<string, number>>>;
@@ -116,7 +116,7 @@ export function normalizeOptions(
   applyDebounceAndThrottle(finalOptionsForComponent.methods);
 
   // 处理watch配置,注意的是 oldValue中的计算属性初始赋值在计算属性初始化完毕后,即计算属性初始化后,再变化时才会被watch到。
-  watchHandler(finalOptionsForComponent);
+  handleWatchConfig(finalOptionsForComponent);
 
   // BBeforeCreate在最后面,让BeforeCreate生命周期运行在最终建立组件时。用于测试。
   finalOptionsForComponent.behaviors.push(BBeforeCreate);

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

@@ -7,15 +7,6 @@ import type { Instance } from "../../../RootComponent/Instance/RootComponentInst
 import { getPathsValue } from "../watchHandler/getPathsValue";
 import { hasComputedPath } from "../watchHandler/hasComputedPath";
 import { initComputedAndGetCache } from "./initComputedAndGetCache";
-// function initWatchOldValue(this: Instance, watchConfig: object): WatchOldValue {
-//   const watchOldValue: Record<string, unknown[]> = {};
-//   for (const key in watchConfig) {
-//     watchOldValue[key] = deepClone(getPathsValue(this.data, key));
-//   }
-
-//   return watchOldValue;
-// }
-
 /**
  * 初始化会在2个时间渲染,一个是observers.**的回调函数,一个是attached周期。
  * @param computedConfig

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

@@ -1,14 +1,14 @@
 import type { Func } from "hry-types/src/Misc/Func";
 
-import type { CustomComponentDefinitionRuntime } from "../../CustomComponent/returnType";
 import type { RootComponentDefinitionRuntime } from "../../RootComponent/returnType";
+import type { SubComponentDefinitionRuntime } from "../../SubComponent/returnType";
 import type { SameFuncOptions } from ".";
 
 /**
  * 把配置为函数的字段方法收集到funcOptions中
  */
 export function sameFuncFieldsCollect(
-  options: CustomComponentDefinitionRuntime | RootComponentDefinitionRuntime,
+  options: SubComponentDefinitionRuntime | RootComponentDefinitionRuntime,
   funcOptions: SameFuncOptions,
 ) {
   let key: keyof SameFuncOptions;

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

@@ -6,7 +6,8 @@ import { getPathsValue } from "./getPathsValue";
 import { getPropertiesValue } from "./getPropertiesValue";
 import { hasComputedPath } from "./hasComputedPath";
 
-function initWatchOldValue(
+// 初始化watch监控字段的旧值对象,排除有计算属性的字段。
+function initWatchOldValuesWithoutComputed(
   data: FinalOptionsOfComponent["data"],
   watchConfig: object,
   computedKeys: string[],
@@ -27,6 +28,7 @@ function observerHandler(
   watchHadle: Func,
   ...newValue: unknown[]
 ) {
+  // 先调用原生observers的回调函数,再调用watch的回调函数。因为watch的回调函数可能会用到原生observers回调函数中更新的数据。
   originObserversHandle?.call(this, ...newValue);
   const watchOldValue = nonNullable(this.data.__watchOldValue__);
   const oldValue = watchOldValue[key];
@@ -34,7 +36,15 @@ function observerHandler(
   watchOldValue[key] = deepClone(newValue);
   watchHadle.call(this, ...newValue, ...oldValue);
 }
-export function watchHandler(
+
+/**
+ * 把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 } =
@@ -42,17 +52,24 @@ export function watchHandler(
   if (!isEmptyObject(watchConfig)) {
     const rawPropertiesValue = getPropertiesValue(properties);
     const computedKeys = Object.keys(computedConfig);
-    data.__watchOldValue__ = initWatchOldValue({ ...data, ...rawPropertiesValue }, watchConfig, computedKeys);
+
+    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, ...newValue: unknown[]) {
+      observersConfig[key] = function(this: Instance, ...values: unknown[]) {
+        // 计算属性初始化完成时直接调用。
         if (this.data.__computedInited__) {
-          observerHandler.call(this, key, originObserversHandle, watchHadle, ...newValue);
+          observerHandler.call(this, key, originObserversHandle, watchHadle, ...values);
         } else {
+          // 计算属性未初始化完成时,先把watch的回调函数注册到实例上,等计算属性初始化完成时再调用。因为计算属性初始化完成时会把data中的值setData一次,会触发observers回调函数,所以在这里注册watch的回调函数,就能保证计算属性初始化完成后能正确调用watch的回调函数。
           (this.data.__oberverHandler__ ||= []).push(
-            observerHandler.bind(this, key, originObserversHandle, watchHadle, ...newValue),
+            observerHandler.bind(this, key, originObserversHandle, watchHadle, ...values),
           );
         }
       };

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

@@ -1,7 +1,7 @@
 import type { IfExtends } from "hry-types/src/Any/IfExtends";
 import type { ComputeIntersection } from "hry-types/src/Object/ComputeIntersection";
-import type { CustomComponentDefinition } from "../../CustomComponent/returnType";
 import type { RootComponentDefinition } from "../../RootComponent/returnType";
+import type { SubComponentDefinition } from "../../SubComponent/returnType";
 import type { GetCustomEventDocOfSubDoc } from "./GetCustomEventDocOfSubDoc";
 
 // 获取RootComponetDoc中events字段类型阻止事件(后最为catch)的key `${ 组件前缀 }_${infer Key}_${ bubbles | capture }_catch`
@@ -13,7 +13,7 @@ type GetStopKeys<O> = { [k in keyof O]: k extends `${string}_${infer Key}_${stri
 export type GenerateComponentDoc<
   TRootDoc extends RootComponentDefinition,
   TName extends string,
-  TSubComponentTuple extends CustomComponentDefinition[],
+  TSubComponentTuple extends SubComponentDefinition[],
   // 获取RootDoc和SubComponent[]中所有的properties字段类型
   AllPropertiesDoc extends unknown | object = TRootDoc["properties"],
   AllEventsDoc extends unknown | object =

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

@@ -2,16 +2,16 @@ import type { IsNever, IsUnion } from "hry-types/src/Any/_api";
 import type { UnionTwoObject } from "hry-types/src/Object/UnionTwoObject";
 import type { Last } from "hry-types/src/Union/Last";
 import type { Assert } from "../../../types/Assert";
-import type { CustomComponentDefinition } from "../../CustomComponent/returnType";
+import type { SubComponentDefinition } from "../../SubComponent/returnType";
 
 /**
  * 因为子组件文档customEvents字段有可能相同(无前缀),所以使用UnionTwoObject
  * 由于SubComponentDoc为空时返回never而不`{}`,所以`Exclude<U, TLast>`不影响结果。
  */
 type _GetCustomEventDocOfSubDoc<
-  U extends CustomComponentDefinition,
+  U extends SubComponentDefinition,
   Result = {},
-  TLast extends CustomComponentDefinition = Assert<Last<U>, CustomComponentDefinition>,
+  TLast extends SubComponentDefinition = Assert<Last<U>, SubComponentDefinition>,
 > = IsNever<U> extends true ? Result
   : _GetCustomEventDocOfSubDoc<Exclude<U, TLast>, UnionTwoObject<Result, TLast["composedEvents"]>>;
 
@@ -19,6 +19,6 @@ type _GetCustomEventDocOfSubDoc<
  * 获取子组件自定义事件文档
  * @remarks U 中 相同字段类型联合,所以使用元组推导不如Last性能好。
  */
-export type GetCustomEventDocOfSubDoc<UnionSubDoc extends CustomComponentDefinition> = IsUnion<UnionSubDoc> extends true
+export type GetCustomEventDocOfSubDoc<UnionSubDoc extends SubComponentDefinition> = IsUnion<UnionSubDoc> extends true
   ? _GetCustomEventDocOfSubDoc<UnionSubDoc>
   : UnionSubDoc["composedEvents"];

package/src/api/DefineComponent/returnType/test/normalComponentDoc.test.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions */
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { Checking, type Test } from "hry-types";
-import { CustomComponent, type DetailedType, RootComponent } from "../../../..";
+import { type DetailedType, RootComponent, SubComponent } from "../../../..";
 // import type { CustomEventConstraint } from "../../../rootComponent/CustomEvents/CustomEventConstraint";
 import type {
   Bubbles,
@@ -14,11 +14,11 @@ import type {
 } from "../../../RootComponent/CustomEvents/CustomEventsTag";
 
 import type { ComputeIntersection } from "hry-types/src/Object/ComputeIntersection";
-import type { CustomComponentDefinition } from "../../../CustomComponent/returnType";
 import type { CustomEventConstraint } from "../../../RootComponent/CustomEvents/CustomEventConstraint";
 import type { PropertiesConstraint } from "../../../RootComponent/Properties/PropertiesConstraint";
 import type { Mock_User } from "../../../RootComponent/Properties/test/normalRequired.test";
 import type { RootComponentDefinition } from "../../../RootComponent/returnType";
+import type { SubComponentDefinition } from "../../../SubComponent/returnType";
 import { DefineComponent } from "../..";
 
 const properties = {
@@ -134,7 +134,7 @@ const compDoc = DefineComponent({
 
 Checking<typeof compDoc, ComputeIntersection<CompOnlyCustomEventsExpected & OnlyPropertiesExpected>, Test.Pass>;
 
-type SubA = CustomComponentDefinition<{
+type SubA = SubComponentDefinition<{
   composedEvents: {
     str: string | Bubbles | Composed;
     num: number | Capture | Composed;
@@ -158,7 +158,7 @@ type customEventsRootDocExpect = {
 
 Checking<typeof customEventsRootDoc, customEventsRootDocExpect, Test.Pass>;
 
-type SubB = CustomComponentDefinition<{
+type SubB = SubComponentDefinition<{
   composedEvents: {
     str: number | Bubbles | Composed;
     num: string | Capture | Composed;
@@ -225,9 +225,9 @@ const rootComponent8 = RootComponent()({
 
 Checking<(typeof rootComponent8)["customEvents"]["decrease"], Mock_User, Test.Pass>;
 
-const subA = CustomComponent<RootComponentDefinition, { properties: { subA_num: number } }>()({});
+const subA = SubComponent<RootComponentDefinition, { properties: { subA_num: number } }>()({});
 // SubComponent中计算属性字段函数若不写返回值,会造成结果中没有计算属性字段类型,若没有其他字段,结果就为'{}'
-const subB = CustomComponent<RootComponentDefinition, { properties: { subB_str: string } }>()({
+const subB = SubComponent<RootComponentDefinition, { properties: { subB_str: string } }>()({
   computed: {
     subB_str() {
       return this.data.injectStr;

package/src/api/RootComponent/Instance/test/properties/mormal.test.ts

@@ -44,7 +44,7 @@ RootComponent()({
   pageLifetimes: {
     onLoad(data) {
       Checking<typeof data, {
-        optionalObj?: {
+        optionalObj: {
           name: string;
         };
         obj: object;

package/src/api/RootComponent/PageLifetimes/PageLifetimesOption.ts

@@ -1,24 +1,12 @@
 import type { IfExtends } from "hry-types/src/Any/IfExtends";
 import type { ComputeIntersection } from "hry-types/src/Object/ComputeIntersection";
-import type { ComputeObject } from "../../../types/ComputeObject";
 import type { WMCompPageLifetimes, WMPageLifetimes } from "../../../types/OfficialTypeAlias";
-import type { RemoveNullOfRequired } from "../../../types/RemoveNullOfRequired";
 
 export type PageLifetimesOption<TIsPage extends boolean, PropertiesDoc extends object> = IfExtends<
   TIsPage,
   false,
   {
-    pageLifetimes?: ComputeIntersection<
-      // 官方组件页面生命周期
-      & Partial<WMCompPageLifetimes>
-      & {
-        /**
-         * 周期发生在组件attached之后,页面onLoad之前,要求组件为同步组件
-         * 最低基础库： `3.0.2`
-         */
-        load?: (props?: object) => void;
-      }
-    >;
+    pageLifetimes?: Partial<WMCompPageLifetimes>;
   },
   {
     /**
@@ -33,8 +21,7 @@ export type PageLifetimesOption<TIsPage extends boolean, PropertiesDoc extends o
          * 页面加载时触发。一个页面只会调用一次，可以在 onLoad 的参数中获取Properties定义的数据。
          */
         onLoad?: (
-          // 默认PropertiesDoc
-          props: ComputeObject<RemoveNullOfRequired<PropertiesDoc>>,
+          props: Required<PropertiesDoc>,
         ) => void | Promise<void>;
       }
     >;

package/src/api/RootComponent/PageLifetimes/test/error.test.ts

@@ -13,9 +13,6 @@ RootComponent()({
     resize() {
       void 0;
     },
-    load(props) {
-      void props;
-    },
     // @ts-expect-error 1 错误的声明周期
     xxx() {
       void 0;

package/src/api/RootComponent/PageLifetimes/test/normal.test.ts

@@ -2,10 +2,7 @@ import { Checking, type Test } from "hry-types";
 import { type DetailedType, RootComponent } from "../../../..";
 
 import type { Mock_User } from "../../Properties/test/normalRequired.test";
-type User = {
-  name: string;
-  age?: number;
-};
+
 /**
  * 组件时
  */
@@ -21,11 +18,6 @@ RootComponent()({
     show() {
       void 0;
     },
-    // 1 glass-easel(最低版本库3.0.2)支持的周期函数
-    load(obj) {
-      void obj;
-      void Checking<typeof obj, object | undefined, Test.Pass>;
-    },
   },
 });
 
@@ -54,8 +46,8 @@ RootComponent()({
       void Checking<
         typeof props,
         {
-          union?: Mock_User;
-          optionalObject?: Mock_User | null;
+          union: Mock_User;
+          optionalObject: Mock_User | null;
           str: string;
           obj: object;
         },
@@ -77,28 +69,3 @@ RootComponent()({
     // ...
   },
 });
-// prop中必传对象没有null,但在实例中却需要有null
-RootComponent()({
-  isPage: true,
-  properties: {
-    optionalObj: {
-      type: Object,
-      value: {},
-    },
-    requiredObj: Object as DetailedType<User>,
-  },
-
-  pageLifetimes: {
-    onLoad(prop) {
-      void prop;
-      // 页面外部传值时没必要传null,组件时有需要的。
-      void Checking<typeof prop.requiredObj, User, true>;
-      // 虽然传值不应该是null,但由于实例建立时默认为null,所以实例类型加上null
-      void Checking<typeof this.data.requiredObj, User, true>;
-      // 页面传入的可选对象不需要null,有undefined
-      void Checking<typeof prop.optionalObj, object | undefined, true>;
-      // 实例中的可选对象不需要null,有默认值。
-      void Checking<typeof this.data.optionalObj, object, true>;
-    },
-  },
-});

package/src/api/RootComponent/Properties/GetPropertiesDef.ts

@@ -3,17 +3,14 @@ import type { Select } from "hry-types/src/Object/Select";
 import type { ComputeIntersection } from "hry-types/src/Object/_api";
 import type { GetOptionalDef } from "./GetOptionalDef";
 
+import type { As } from "hry-types/src/Any/As";
 import type { GetRequiredDef } from "./GetRequiredDef";
-import type { OptionalType, PropertiesConstraint } from "./PropertiesConstraint";
+import type { OptionalType, PropertiesConstraint, RequiredType } from "./PropertiesConstraint";
 
 type _GetPropertiesDef<
   TProperties extends PropertiesConstraint,
-  OptionalDef extends object =
-    // @ts-expect-error ddd
-    GetOptionalDef<Select<TProperties, OptionalType>>,
-  RequiredDef extends object =
-    // @ts-expect-error dddf
-    GetRequiredDef<Omit<TProperties, keyof OptionalDef>>,
+  OptionalDef extends object = GetOptionalDef<As<Select<TProperties, OptionalType>, Record<string, OptionalType>>>,
+  RequiredDef extends object = GetRequiredDef<As<Omit<TProperties, keyof OptionalDef>, Record<string, RequiredType>>>,
 > = ComputeIntersection<OptionalDef & RequiredDef>;
 
 /**

package/src/api/RootComponent/Properties/PropertiesOption.ts

@@ -1,4 +1,3 @@
-import type { G } from "hry-types";
 import type { Validators } from "../../../types/Validators";
 import type { PropertiesConstraint } from "./PropertiesConstraint";
 import type { PropertiesValueValidator } from "./PropertiesValueValidator";
@@ -12,7 +11,7 @@ export type PropertiesOption<
    *
    * 禁用observable字段(watch代替)
    *
-   * 简写或对象写法(无value字段)时为必传属性(组件时必传对象实际类型加入null,页面不加),对象写法有value字段为可选属性.
+   * 简写 → 必传，单一类型。对象写法 + optionalTypes → 必传，联合类型。对象写法 + value → 可选传（有默认值），可同时配合 optionalTypes。
    *
    * 有value类型检测和非法字段检测(例如value写出values)
    */
@@ -20,7 +19,7 @@ export type PropertiesOption<
     & TProperties
     & Validators<[
       PropertiesValueValidator<TProperties>,
-      // 放在最后一个，正常返回不是unknown 而是Record<string,unknown>
-      G.IllegalFieldValidator<TProperties, "value" | "type" | "optionalTypes", 1>,
+      // // 放在最后一个，正常返回不是unknown 而是Record<string,unknown>
+      // G.IllegalFieldValidator<TProperties, "value" | "type" | "optionalTypes", 1>,
     ]>;
 };

package/src/api/RootComponent/Store/StoreOption.ts

@@ -33,7 +33,7 @@ export type StoreOption<
     & TStore
     & Validators<[
       G.DuplicateFieldValidator<TStore, TDuplicateKeys, "字段重复">,
-      TypeValidator<TStore>,
+      // TypeValidator<TStore>,
     ]>;
 };
 /**

package/src/api/RootComponent/Store/test/error.test.ts

@@ -8,7 +8,7 @@ const user = observable({
 // 1 约束错误
 RootComponent()({
   store: {
-    // @ts-expect-error 1.1 不能将类型“string”分配给类型“() => unknown”
+    // @ts-expect-error 1.1 不能将类型“string”分配给类型“Getter<{}, unknown>”
     userName: user.name,
   },
 });
@@ -28,10 +28,3 @@ RootComponent()({
     userAge: () => user.age,
   },
 });
-// 3. 返回类型错误
-RootComponent()({
-  store: {
-    // @ts-expect-error 3.1 返回类型中不可以包含undefined
-    xxx: () => "xxx" as string | undefined,
-  },
-});

package/src/api/RootComponent/Store/test/normal.test.ts

@@ -1,5 +1,5 @@
-import { Checking, type Test } from "hry-types";
 import { observable } from "mobx";
+import { typeEqual } from "../../../../utils/_utils";
 import { RootComponent } from "../..";
 const user = observable({
   name: "zhao",
@@ -7,18 +7,29 @@ const user = observable({
 });
 
 const storeDoc = RootComponent()({
+  properties: {
+    condition: Number,
+  },
   store: {
+    // normal
     userName: () => user.name,
-    userAge: () => user.age,
+    // 条件反应式,当condition>10时,响应式,否则不可响应式(返回undefined),但不报错(有警告).
+    userAge: (props) => {
+      if (props.condition > 10) {
+        return user.age;
+      }
+      return undefined;
+    },
   },
 });
-void storeDoc;
-interface StoreDocExpected {
+
+type StoreDocExpected = {
+  properties: {
+    condition: number;
+  };
   store: {
     userName: string;
-    userAge: number;
+    userAge: number | undefined;
   };
-}
-
-// 返回类型为函数返回类型
-void Checking<typeof storeDoc, StoreDocExpected, Test.Pass>;
+};
+typeEqual<StoreDocExpected>()(storeDoc);

package/src/api/{CustomComponent/CustomComputed/GetCustomComputedDoc.ts → SubComponent/SubComputed/GetSubComputedDoc.ts}

@@ -1,4 +1,4 @@
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type GetCustomComputedDoc<TComputed extends Record<string, any>> = {
+export type GetSubComputedDoc<TComputed extends Record<string, any>> = {
   [k in keyof TComputed]: ReturnType<TComputed[k]>;
 };

package/src/api/SubComponent/SubComputed/SubComputedConstraint.ts

@@ -0,0 +1 @@
+export type SubComputedConstraint<obj extends object> = { [k in keyof obj]?: () => obj[k] };

package/src/api/{CustomComponent/CustomComputed/CustomComputedOption.ts → SubComponent/SubComputed/SubComputedOption.ts}

@@ -1,5 +1,5 @@
 import type { G } from "hry-types";
-export type CustomComputedOption<
+export type SubComputedOption<
   TComputed extends object,
   legal extends PropertyKey,
 > // Instance extends object,

package/src/api/{CustomComponent/CustomComputed → SubComponent/SubComputed}/test/error.test.ts

@@ -1,12 +1,12 @@
 import type { ComponentDoc } from "../../../DefineComponent/returnType/ComponentDoc";
-import { CustomComponent } from "../..";
+import { SubComponent } from "../..";
 
 type OnlyCustomCompDoc = ComponentDoc<{
   events: { aaa_str: string };
 }>;
 
 // 1 CompDoc的properties为空时,写任何字段都报错
-CustomComponent<{}, OnlyCustomCompDoc>()({
+SubComponent<{}, OnlyCustomCompDoc>()({
   computed: {
     // @ts-expect-error ⚠️"重复或无效的字段"⚠️
     aaa_xxx() {
@@ -23,7 +23,7 @@ type OnlyPropsCompDoc = ComponentDoc<{
 }>;
 
 // 2 去除inhrit和data字段后无组件字段约束时,只可写内部字段
-CustomComponent<{}, OnlyPropsCompDoc>()({
+SubComponent<{}, OnlyPropsCompDoc>()({
   inherit: {
     aaa_str: "wxml",
   },
@@ -42,7 +42,7 @@ CustomComponent<{}, OnlyPropsCompDoc>()({
 });
 
 // 3 类型错误
-CustomComponent<{}, OnlyPropsCompDoc>()({
+SubComponent<{}, OnlyPropsCompDoc>()({
   inherit: {
     aaa_str: "wxml",
   },
@@ -54,7 +54,7 @@ CustomComponent<{}, OnlyPropsCompDoc>()({
   },
 });
 // 4 与data的内部字段重复
-CustomComponent<{}, OnlyPropsCompDoc>()({
+SubComponent<{}, OnlyPropsCompDoc>()({
   data: {
     _aaa_fff: 123,
   },
@@ -66,7 +66,7 @@ CustomComponent<{}, OnlyPropsCompDoc>()({
   },
 });
 // 5 与store的内部字段重复
-CustomComponent<{}, OnlyPropsCompDoc>()({
+SubComponent<{}, OnlyPropsCompDoc>()({
   store: {
     _aaa_ccc: () => 123,
   },
@@ -78,7 +78,7 @@ CustomComponent<{}, OnlyPropsCompDoc>()({
   },
 });
 // 6 与root字段重复
-CustomComponent<{ data: { _aaa_ccc: 123 } }, OnlyPropsCompDoc>()({
+SubComponent<{ data: { _aaa_ccc: 123 } }, OnlyPropsCompDoc>()({
   computed: {
     // @ts-expect-error 与store的内部字段重复
     _aaa_ccc(): number {