annil 1.0.0

package/src/api/SubComponent/SubData/test/error.test.ts

@@ -0,0 +1,56 @@
+import type { ComponentDoc } from "../../../DefineComponent/ReturnType/ComponentDoc";
+import type { Mock_User } from "../../../RootComponent/Properties/expected/normalRequired";
+import { SubComponent } from "../..";
+
+type OnlyCustomCompDoc = ComponentDoc<{
+  customEvents: { aaa_str: string };
+}>;
+
+// 1 CompDoc无properties字段时 data字段只可写内部字段
+SubComponent<{}, OnlyCustomCompDoc>()({
+  data: {
+    // @ts-expect-error "⚠️ 与Inherit字段重复或组件文档无需字段 ⚠️"
+    aaa_str: "str",
+    _aaa_str: "str", // 内部字段 ok
+  },
+});
+
+type OnlyPropsCompDoc = ComponentDoc<{
+  properties: {
+    aaa_str: "a" | "b";
+    aaa_num?: number;
+    aaa_obj?: Mock_User | null;
+  };
+}>;
+
+// 2 CompDoc有properties字段但去除Inherit字段后为空,只可写临时字段(内部字段)
+SubComponent<{}, OnlyPropsCompDoc>()({
+  inherit: {
+    aaa_str: "wxml",
+    aaa_num: "wxml",
+    aaa_obj: "wxml",
+  },
+  data: {
+    // @ts-expect-error "⚠️ 与Inherit字段重复或组件文档无需字段 ⚠️"
+    aaa_str: "123",
+    // @ts-expect-error "⚠️ 与Inherit字段重复或组件文档无需字段 ⚠️"
+    errorfield: "str",
+    _aaa_str: "内部字段", // ok
+  },
+});
+
+// 3 重复字段和非组件所需字段错误
+SubComponent<{}, OnlyPropsCompDoc>()({
+  inherit: {
+    aaa_str: "wxml",
+  },
+  data: {
+    aaa_num: 123, // ok
+    aaa_obj: null, // ok
+    // @ts-expect-error "⚠️ Inherit字段重复 ⚠️"
+    aaa_str: "123",
+    // @ts-expect-error  "⚠️ 组件文档无需字段 ⚠️"
+    aaa_xxx: "组件文档无需字段会报错",
+    _aaa_xxx: 123, // ok 内部字段可写
+  },
+});

package/src/api/SubComponent/SubData/test/normal.test.ts

@@ -0,0 +1,91 @@
+import { Checking, type Test } from "hry-types";
+import type { ReadonlyDeep } from "hry-types/src/Any/_api";
+import type { Wm } from "../../../../thirdLib";
+import type { CompDocExtends } from "../../../../types/CompDocExtends";
+import type { ComponentDoc } from "../../../DefineComponent/ReturnType/ComponentDoc";
+import type { Mock_User } from "../../../RootComponent/Properties/expected/normalRequired";
+import { SubComponent } from "../..";
+
+type CompDoc = ComponentDoc<{
+  properties: {
+    aaa_str: "a" | "b";
+    aaa_num?: number;
+    aaa_obj?: Mock_User | null;
+  };
+}>;
+
+// 1 data字段的key提示为:组件文档字段去除inherit字段后的字段.值类型为:文档对应字段类型或函数返回类型(表示引入的Store数据)。或临时字段(内部运算所用字段,无法渲染到页面)key,值类型为unknown
+SubComponent<{}, CompDoc>()({
+  inherit: {
+    aaa_obj: "wxml",
+  },
+  data: {
+    aaa_str: "a",
+    aaa_num: 123,
+    _aaa_template: "internal", // 内部临时数据
+  },
+});
+
+// 2. 使用CompDocExtends泛型拓展组件文档,满足内部组件内部包含一些slot或基本组件数据
+type viewExtends = CompDocExtends<Wm.View, { view_obj: Mock_User | null; view_str: string; view_ddd: number }>;
+
+const res = SubComponent<{}, viewExtends>()({
+  inherit: {
+    view_style: "wxml",
+  },
+  data: {
+    // view组件key
+    view_class: "h-full",
+    view_hover_class: "none",
+    // 拓展的字段
+    view_obj: {} as Mock_User | null,
+    view_str: "a",
+    view_ddd: 123,
+  },
+});
+
+Checking<typeof res, never, Test.Pass>;
+
+// 2  CompDoc去除Inherit字段后为空,可写非临时字段(内部字段)
+SubComponent<{}, CompDoc>()({
+  inherit: {
+    aaa_str: "wxml",
+    aaa_num: "wxml",
+    aaa_obj: "wxml",
+  },
+  data: {
+    _aaa_str: "str",
+  },
+});
+
+// 3 CompDoc 为空对象时,参数为空对象,返回never
+
+type EmptyCompDoc = ComponentDoc<{}>;
+
+const res1 = SubComponent<{}, EmptyCompDoc>()({});
+
+Checking<typeof res1, never, Test.Pass>;
+
+SubComponent<{}, CompDoc>()({
+  data: {
+    aaa_str: "a",
+    aaa_num: 123,
+    aaa_obj: null,
+    _aaa_str: "str",
+  },
+  methods: {
+    aaa_1() {
+      // 4 this.data 深度只读
+      Checking<
+        typeof this.data,
+        ReadonlyDeep<{
+          aaa_str: "a";
+          aaa_num: 123;
+          aaa_obj: null;
+          _aaa_str: string;
+        }>,
+        Test.Pass
+      >;
+    },
+  },
+});

package/src/api/SubComponent/SubEvents/SubEventsConstraint.ts

@@ -0,0 +1,22 @@
+import type { Contains } from "hry-types/src/Any/Contains";
+import type { IfExtends } from "hry-types/src/Any/IfExtends";
+import type { Detail, WMBaseEvent } from "../../../types/OfficialTypeAlias";
+import type { ComponentDoc } from "../../DefineComponent/ReturnType/ComponentDoc";
+import type { Bubbles, Capture, CustomEventsTags } from "../../RootComponent/CustomEvents/CustomEventsTag";
+
+export type SubEventsConstraint<
+  CompDoc extends ComponentDoc,
+  keys extends keyof CompDoc["customEvents"] = keyof CompDoc["customEvents"],
+> = {
+  [
+    k in keys as Contains<CompDoc["customEvents"][k], Bubbles | Capture> extends true ? (k | `${k & string}_catch`)
+      : k
+  ]?: (
+    e: IfExtends<
+      WMBaseEvent,
+      CompDoc["customEvents"][k],
+      WMBaseEvent,
+      Detail<Exclude<CompDoc["customEvents"][k], CustomEventsTags>>
+    >,
+  ) => void;
+};

package/src/api/SubComponent/SubEvents/SubEventsOptions.ts

@@ -0,0 +1,7 @@
+import type { V } from "hry-types";
+
+export type SubEventsOption<TSubEvents, SubEventsDoc extends object, xxx extends PropertyKey> = {
+  events?:
+    & TSubEvents
+    & V.IllegalFieldValidator<SubEventsDoc, xxx>;
+};

package/src/api/SubComponent/SubEvents/test/error.test.ts

@@ -0,0 +1,33 @@
+import type { ComponentDoc } from "../../../DefineComponent/ReturnType/ComponentDoc";
+import { SubComponent } from "../..";
+
+type CompDoc = ComponentDoc<{
+  properties: {
+    aaa_str: string;
+  };
+}>;
+
+// 组件文档无自定义事件时,events字段类型为EmptyObject
+SubComponent<{}, CompDoc>()({
+  events: {
+    // @ts-expect-error 非法字段
+    xxx: 123,
+  },
+});
+
+type CompDoc1 = ComponentDoc<{
+  customEvents: {
+    aaa_str: string;
+  };
+}>;
+
+// 组件文档有自定义事件时,events下的字段仅可写文档包含字段
+SubComponent<{}, CompDoc1>()({
+  events: {
+    aaa_str(e) {
+      e;
+    }, // ok
+    // @ts-expect-error 非法字段
+    aaa_other() {},
+  },
+});

package/src/api/SubComponent/SubEvents/test/normal.test.ts

@@ -0,0 +1,128 @@
+import { Checking, type Test } from "hry-types";
+import type { Wm } from "../../../../thirdLib";
+import type { Detail, WMBaseEvent } from "../../../../types/OfficialTypeAlias";
+import type { ComponentDoc } from "../../../DefineComponent/ReturnType/ComponentDoc";
+import type {
+  Bubbles,
+  BubblesCapture,
+  BubblesCaptureComposed,
+  BubblesComposed,
+  Capture,
+  CaptureComposed,
+} from "../../../RootComponent/CustomEvents/CustomEventsTag";
+import { SubComponent } from "../..";
+
+type CompDoc = ComponentDoc<{
+  customEvents: {
+    aaa_str: string;
+    aaa_bubbles: string | Bubbles;
+    aaa_CapturePhase: string | Capture;
+    aaa_BubblesCapturePhase: null | BubblesCapture;
+    aaa_BubblesComposed: string | BubblesComposed;
+    aaa_CapturePhaseComposed: string | CaptureComposed;
+    aaa_BubblesCapturePhaseComposed: string | BubblesCaptureComposed;
+  };
+}>;
+
+// 1.1 events字段提示 key为 CompDoc下customEvents的字段,类型为函数(e)=>void,e为对应keys类型去除事件标记(冒泡 捕获 穿透)
+const sub1 = SubComponent<{}, CompDoc>()({
+  events: {
+    aaa_str(e) {
+      Checking<typeof e.detail, string, Test.Pass>;
+    },
+    aaa_bubbles(e) {
+      Checking<typeof e.detail, string, Test.Pass>;
+    },
+    aaa_CapturePhase(e) {
+      Checking<typeof e.detail, string, Test.Pass>;
+    },
+    aaa_BubblesCapturePhase(e) {
+      Checking<typeof e.detail, null, Test.Pass>;
+    },
+    aaa_BubblesComposed(e) {
+      Checking<typeof e.detail, string, Test.Pass>;
+    },
+    aaa_CapturePhaseComposed(e) {
+      Checking<typeof e.detail, string, Test.Pass>;
+    },
+    aaa_BubblesCapturePhaseComposed(e) {
+      Checking<typeof e.detail, string, Test.Pass>;
+    },
+  },
+});
+
+// 1.2 Composed事件会被返回
+type Sub1Expected = {
+  BubblesComposed: string | BubblesComposed;
+  CapturePhaseComposed: string | CaptureComposed;
+  BubblesCapturePhaseComposed: string | BubblesCaptureComposed;
+};
+
+Checking<typeof sub1, Sub1Expected, Test.Pass>;
+
+// 2.1 key可写入后缀字段(_catch,表示阻止冒泡和捕获事件)。
+const sub2 = SubComponent<{}, CompDoc>()({
+  events: {
+    aaa_BubblesComposed_catch(e) {
+      Checking<typeof e.detail, string, Test.Pass>;
+    },
+    aaa_CapturePhaseComposed_catch(e) {
+      Checking<typeof e.detail, string, Test.Pass>;
+    },
+  },
+});
+
+// 2.2 返回没有被加后最(_catch)的Composed事件
+Checking<typeof sub2, { BubblesCapturePhaseComposed: string | BubblesCaptureComposed }, Test.Pass>;
+
+// 2.3 key可写入后缀字段(_catch,表示阻止冒泡和捕获事件)。
+const sub3 = SubComponent<{}, CompDoc>()({
+  events: {
+    aaa_BubblesComposed_catch(e) {
+      Checking<typeof e.detail, string, Test.Pass>;
+    },
+    aaa_CapturePhaseComposed_catch(e) {
+      Checking<typeof e.detail, string, Test.Pass>;
+    },
+    aaa_BubblesCapturePhaseComposed_catch(e) {
+      Checking<typeof e.detail, string, Test.Pass>;
+    },
+  },
+});
+
+// 2.4 若Composed事件都被阻止则返回never
+Checking<typeof sub3, never, Test.Pass>;
+
+// 3.1 基础组件基本事件参数为WMBaseEvent
+SubComponent<{}, Wm.View>()({
+  events: {
+    view_tap(e) {
+      Checking<typeof e, WMBaseEvent, Test.Pass>;
+    },
+    view_longtap(e) {
+      Checking<typeof e, WMBaseEvent, Test.Pass>;
+    },
+    // ...
+  },
+});
+
+// 3.2 基础组件自定义事件参数为Detail<object>
+SubComponent<{}, Wm.ScrollView>()({
+  events: {
+    scrollView_bindscroll(e) {
+      Checking<
+        typeof e,
+        Detail<{
+          scrollLeft: number;
+          scrollTop: number;
+          scrollHeight: number;
+          scrollWidth: number;
+          deltaX: number;
+          deltaY: number;
+        }>,
+        Test.Pass
+      >;
+    },
+    // ...
+  },
+});

package/src/api/SubComponent/SubInherit/SubInheritConstraint.ts

@@ -0,0 +1,12 @@
+import type { SelectKeys } from "hry-types/src/Object/_api";
+import type { ComponentDoc } from "../../DefineComponent/ReturnType/ComponentDoc";
+
+type WXMLSign = "wxml";
+
+/**
+ * 子组件inherit字段约束,
+ * @returns object
+ */
+export type InheritConstraint<RootData extends object, TComponentDoc extends ComponentDoc> = {
+  [k in keyof TComponentDoc["properties"]]?: SelectKeys<RootData, TComponentDoc["properties"][k]> | WXMLSign;
+};

package/src/api/SubComponent/SubInherit/test/error.test.ts

@@ -0,0 +1,62 @@
+import { Checking, type Test } from "hry-types";
+import { DefineComponent } from "../../../DefineComponent";
+import type { ComponentDoc } from "../../../DefineComponent/ReturnType/ComponentDoc";
+import type { RootComponentDoc } from "../../../RootComponent/RootComponentDoc";
+import { SubComponent } from "../..";
+import type { SubComponentDoc } from "../../SubComponentDoc";
+
+type Mock_RootDoc = RootComponentDoc<{
+  properties: {
+    required_num: number;
+    optional_literal_num?: 123 | 456 | 789;
+    unionStrNum: string | number;
+    required_obj: object | null;
+    optional_obj?: object;
+  };
+  data: {
+    str: string;
+    literal_str: "a" | "b" | "c";
+    bool: boolean;
+  };
+  computed: {
+    Cuinon: string | boolean;
+  };
+}>;
+
+type Mock_CompDoc = ComponentDoc<{
+  properties: {
+    aaa_num: number;
+    aaa_literal_num: 123 | 456;
+    aaa_str?: string;
+    aaa_union: string | boolean;
+    aaa_obj: object | null;
+    aaa_obj1?: object | null;
+  };
+}>;
+
+// RootDoc不为空时,可继承对应类型的字段。
+SubComponent<Mock_RootDoc, Mock_CompDoc>()({
+  inherit: {
+    // @ts-expect-error  [string | number] 不是 [number] 的子集
+    aaa_num: "unionStrNum",
+    // @ts-expect-error  [123 | 456 | 789] 不是 [123 | 456] 的子集
+    aaa_literal_num: "optional_literal_num",
+    // @ts-expect-error  [string | number] 不是 [string] 的子集
+    aaa_str: "" as "unionStrNum",
+  },
+});
+
+// inherit字段最终不会在组件配置中,意义在于通过声明继承字段便于类型判断,配置是否满足组件的需求。下面示例中,配置不满足组件需求,Mock_CompDoc需要一些必传字段没有配置,即使这些字段存在在于根组件(或wmxl).而返回的字符串(错误),无法通过DefinedComponent Api 类型检测。
+const subDoc = SubComponent<Mock_RootDoc, Mock_CompDoc>()({
+  data: {
+    aaa_num: 123,
+  },
+});
+
+Checking<typeof subDoc, SubComponentDoc, Test.Fail>;
+
+DefineComponent({
+  name: "xxx",
+  // @ts-expect-error 不能将类型“string”分配给类型“_SubComponentDoc”。
+  subComponents: [subDoc],
+});

package/src/api/SubComponent/SubInherit/test/normal.test.ts

@@ -0,0 +1,55 @@
+import type { ComponentDoc } from "../../../DefineComponent/ReturnType/ComponentDoc";
+import type { RootComponentDoc } from "../../../RootComponent/RootComponentDoc";
+import { SubComponent } from "../..";
+
+type Mock_RootDoc = RootComponentDoc<{
+  properties: {
+    required_num: number;
+    optional_literal_num?: 123 | 456 | 789;
+    unionStrNum: string | number;
+    required_obj: object | null;
+    optional_obj?: object;
+  };
+  data: {
+    str: string;
+    literal_str: "a" | "b" | "c";
+    bool: boolean;
+  };
+  computed: {
+    Cuinon: string | boolean;
+  };
+}>;
+
+type Mock_CompDoc = ComponentDoc<{
+  properties: {
+    aaa_num: number;
+    aaa_literal_num: 123 | 456;
+    aaa_str?: string;
+    aaa_union: string | boolean;
+    aaa_obj: object | null;
+    aaa_obj1?: object | null;
+  };
+}>;
+
+// 1 没有可继承的数据,类型可为'wxml',表示数据来自wxml(例如数据来自父组件循环wx:for后的数据等情况)
+SubComponent<{}, Mock_CompDoc>()({
+  inherit: {
+    aaa_num: "wxml",
+    aaa_str: "wxml",
+    aaa_union: "wxml",
+    aaa_obj: "wxml",
+    aaa_obj1: "wxml",
+  },
+});
+
+// 2 RootDoc不为空时,可继承对应类型的字段。
+SubComponent<Mock_RootDoc, Mock_CompDoc>()({
+  inherit: {
+    aaa_num: "" as "optional_literal_num" | "required_num" | "wxml",
+    aaa_str: "" as "str" | "literal_str" | "wxml",
+    aaa_obj: "" as "required_obj" | "optional_obj" | "wxml",
+    aaa_obj1: "" as "required_obj" | "optional_obj" | "wxml",
+  },
+});
+
+// inherit字段最终会在配置对象中删除,它用类型检测。

package/src/api/SubComponent/SubInstance/SubInstance.ts

@@ -0,0 +1,9 @@
+import type { RootComponentInstance } from "../../RootComponent/Instance/RootComponentInstance";
+
+export type SubInstance<
+  TAllMethods extends object,
+  TData extends object,
+  AllData extends object,
+  AllCustomEventsDoc extends object,
+  SubStoreDoc extends object,
+> = RootComponentInstance<false, TAllMethods, TData, AllData, AllCustomEventsDoc, SubStoreDoc>;

package/src/api/SubComponent/SubInstance/test/error.test.ts

@@ -0,0 +1,22 @@
+import type { View } from "../../../../thirdLib/wm";
+import type { RootComponentDoc } from "../../../RootComponent/RootComponentDoc";
+import { SubComponent } from "../..";
+
+type RootDoc = RootComponentDoc<{
+  events: {
+    RootE1: () => string;
+  };
+}>;
+
+// 实例中只存在RootDoc和自身的methods字段
+SubComponent<RootDoc, View>()({
+  lifetimes: {
+    created() {
+      // @ts-expect-error 不存在的方法  (Root事件方法不可调用)
+      this.RootE1;
+
+      // @ts-expect-error 不存在的方法
+      this.otherMethods();
+    },
+  },
+});

package/src/api/SubComponent/SubInstance/test/normal.test.ts

@@ -0,0 +1,83 @@
+import { Checking, type Test } from "hry-types";
+import type { ReadonlyDeep } from "hry-types/src/Any/_api";
+import type { ComponentDoc } from "../../../DefineComponent/ReturnType/ComponentDoc";
+import type { Mock_User } from "../../../RootComponent/Properties/expected/normalRequired";
+import type { RootComponentDoc } from "../../../RootComponent/RootComponentDoc";
+import { SubComponent } from "../..";
+
+type RootDoc = RootComponentDoc<{
+  properties: {
+    Pstr: string;
+    Pobj: Mock_User | null;
+    PoptionalObj?: Mock_User;
+  };
+  data: {
+    Dnum: number;
+  };
+  computed: {
+    Cnum: number;
+  };
+  methods: {
+    RootM: () => number;
+  };
+  customEvents: {
+    RootCus: string;
+  };
+  events: {
+    RootE1: () => string;
+  };
+}>;
+
+type CompDoc = ComponentDoc<{
+  properties: {
+    aaa_str: string;
+  };
+  customEvents: {
+    aaa_num: number;
+  };
+}>;
+
+SubComponent<RootDoc, CompDoc>()({
+  data: {
+    aaa_str: "str",
+  },
+  store: {
+    _aaa_SubReactive: () => 123,
+  },
+  computed: {},
+  methods: {
+    aaa_SubM() {},
+  },
+  events: {
+    aaa_num() {},
+  },
+  lifetimes: {
+    created() {
+      // this.data
+      Checking<
+        typeof this.data,
+        ReadonlyDeep<{
+          // RootData
+          Pstr: string;
+          Pobj: Mock_User | null;
+          PoptionalObj: Mock_User;
+          Dnum: number;
+          Cnum: number;
+          // 自身Data
+          aaa_str: "str";
+          _aaa_SubReactive: 123;
+        }>,
+        Test.Pass
+      >;
+
+      // this.Methods 可调用自身和RootDoc中的methods方法,其他不可以
+      Checking<typeof this.RootM, () => number, Test.Pass>;
+
+      Checking<typeof this.RootCus, (detail: string) => void, Test.Pass>;
+
+      Checking<typeof this.aaa_SubM, () => void, Test.Pass>;
+
+      // 其他官方字段 ...
+    },
+  },
+});

package/src/api/SubComponent/SubLifetimes/SubLifetimesOption.ts

@@ -0,0 +1,3 @@
+import type { WMCompLifetimes } from "../../../types/OfficialTypeAlias";
+
+export type SubLifetimesOption = Partial<WMCompLifetimes>;

package/src/api/SubComponent/SubMethods/SubMethodsConstraint.ts

@@ -0,0 +1,5 @@
+import type { Func } from "hry-types/src/Misc/Func";
+
+export type SubMethodsConstraint = {
+  [x: string]: Func;
+};

package/src/api/SubComponent/SubMethods/SubMethodsOption.ts

@@ -0,0 +1,13 @@
+import type { V } from "hry-types";
+import type { PrefixValidator } from "hry-types/src/Generic/PrefixValidator";
+
+export type SubMethodsOption<
+  TSubMethods extends object,
+  TPrefix extends string,
+  CompCustomEventsKeys extends PropertyKey,
+> = {
+  methods?:
+    & TSubMethods
+    & PrefixValidator<TSubMethods, TPrefix>
+    & V.DuplicateFieldValidator<TSubMethods, CompCustomEventsKeys>;
+};

package/src/api/SubComponent/SubMethods/test/error.test.ts

@@ -0,0 +1,37 @@
+import type { ComponentDoc } from "../../../DefineComponent/ReturnType/ComponentDoc";
+import type { RootComponentDoc } from "../../../RootComponent/RootComponentDoc";
+import { SubComponent } from "../..";
+
+type RootDoc = RootComponentDoc<{
+  methods: {
+    Mstr: () => string;
+  };
+  events: {
+    Estr: () => string;
+  };
+  customEvents: {
+    Cstr: string;
+  };
+}>;
+
+type CompDoc = ComponentDoc<{
+  customEvents: {
+    aaa_str: string;
+  };
+}>;
+
+// 前缀错误
+SubComponent<RootDoc, CompDoc>()({
+  methods: {
+    // @ts-expect-error 前缀错误
+    xxx_yyy() {},
+  },
+});
+
+// 与组件事件字段重复
+SubComponent<RootDoc, CompDoc>()({
+  methods: {
+    // @ts-expect-error 与组件事件字段重复
+    aaa_str() {},
+  },
+});

package/src/api/SubComponent/SubMethods/test/normarl.test.ts

@@ -0,0 +1,35 @@
+import type { ComponentDoc } from "../../../DefineComponent/ReturnType/ComponentDoc";
+import type { RootComponentDoc } from "../../../RootComponent/RootComponentDoc";
+import { SubComponent } from "../..";
+
+type RootDoc = RootComponentDoc<{
+  methods: {
+    Mstr: () => string;
+  };
+  events: {
+    Estr: () => string;
+  };
+  customEvents: {
+    Cstr: string;
+  };
+}>;
+
+type CompDoc = ComponentDoc<{
+  customEvents: {
+    aaa_str: string;
+  };
+}>;
+
+// 默认可以为{}。
+SubComponent<RootDoc, CompDoc>()({
+  methods: {},
+});
+
+// methods字段可以写 任意字段函数,不与RootDoc和CompDoc中的方法字段重复即可,前缀为CompDoc的前缀
+SubComponent<RootDoc, CompDoc>()({
+  methods: {
+    aaa_xxx() {},
+    aaa_yyy() {},
+    // ...
+  },
+});