annil 1.0.0

package/src/api/RootComponent/CustomEvents/test/GetFullEventDoc.test.ts

@@ -0,0 +1,56 @@
+import { Checking, type Test } from "hry-types";
+import type {
+  Bubbles,
+  BubblesCapture,
+  BubblesCaptureComposed,
+  BubblesComposed,
+  Capture,
+  CaptureComposed,
+} from "../CustomEventsTag";
+
+import type { GetFullCustomEventsDoc } from "../GetCustomEventDoc";
+import { mock_fullCustomEvents } from "./normal.test";
+
+// bubbles
+type bubblesResult = GetFullCustomEventsDoc<typeof mock_fullCustomEvents["bubbles"]>;
+
+export type bubblesExpected = string | Bubbles;
+
+Checking<bubblesResult, bubblesExpected, Test.Pass>;
+
+// CapturePhase
+type CapturePhaseResult = GetFullCustomEventsDoc<typeof mock_fullCustomEvents["capturePhase"]>;
+
+export type CapturePhaseExpected = Capture | null;
+
+Checking<CapturePhaseResult, CapturePhaseExpected, Test.Pass>;
+
+// bubbles_capturePhase
+type BubblesCapturePhaseResult = GetFullCustomEventsDoc<typeof mock_fullCustomEvents["bubbles_capturePhase"]>;
+
+export type BubblesCapturePhaseExpected = string | number | BubblesCapture;
+
+Checking<BubblesCapturePhaseResult, BubblesCapturePhaseExpected, Test.Pass>;
+
+// bubbles_composed
+type BubblesComposedResult = GetFullCustomEventsDoc<typeof mock_fullCustomEvents["bubbles_composed"]>;
+
+export type BubblesComposedExpected = "male" | "female" | BubblesComposed;
+
+Checking<BubblesComposedResult, BubblesComposedExpected, Test.Pass>;
+
+// capturePhase_composed
+type CapturePhaseComposedResult = GetFullCustomEventsDoc<typeof mock_fullCustomEvents["capturePhase_composed"]>;
+
+export type CapturePhaseComposedExpected = string | 0 | 1 | 2 | null | CaptureComposed;
+
+Checking<CapturePhaseComposedResult, CapturePhaseComposedExpected, Test.Pass>;
+
+// bubbles_capturePhase_composed
+type BubblesCapturePhaseComposedResult = GetFullCustomEventsDoc<
+  typeof mock_fullCustomEvents["bubbles_capturePhase_composed"]
+>;
+
+export type BubblesCapturePhaseComposedExpected = boolean | BubblesCaptureComposed;
+
+Checking<BubblesCapturePhaseComposedResult, BubblesCapturePhaseComposedExpected, Test.Pass>;

package/src/api/RootComponent/CustomEvents/test/GetShortEventDoc.test.ts

@@ -0,0 +1,28 @@
+import { Checking, type Test } from "hry-types";
+
+import type { GetShortCustomEventsDoc } from "../GetCustomEventDoc";
+import { mock_shortCustomEvents } from "./normal.test";
+
+type StrResult = GetShortCustomEventsDoc<typeof mock_shortCustomEvents["str"]>;
+
+export type StrExpected = string;
+
+Checking<StrResult, StrExpected, Test.Pass>;
+
+type NullResult = GetShortCustomEventsDoc<typeof mock_shortCustomEvents["null"]>;
+
+export type NullExpected = null;
+
+Checking<NullResult, NullExpected, Test.Pass>;
+
+type UnionStrResult = GetShortCustomEventsDoc<typeof mock_shortCustomEvents["unionStr"]>;
+
+export type UnionStrExpected = "male" | "female";
+
+Checking<UnionStrResult, UnionStrExpected, Test.Pass>;
+
+type ListResult = GetShortCustomEventsDoc<typeof mock_shortCustomEvents["union"]>;
+
+export type ListExpected = string | 0 | 1 | 2 | null;
+
+Checking<ListResult, ListExpected, Test.Pass>;

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

@@ -0,0 +1,101 @@
+import { RootComponent } from "../..";
+
+/**
+ * 1 错误的字段类型
+ */
+RootComponent()({
+  customEvents: {
+    // @ts-expect-error options 没有options字段时无需写对象形式,应简写`error1:Boolean`。
+    error1: {
+      detailType: Boolean,
+    },
+    // @ts-expect-error options 不可以为空对象 无意义
+    error2: {
+      detailType: Boolean,
+      options: {},
+    },
+    // @ts-expect-error false字段不要写 默认就为false
+    error3: {
+      detailType: Boolean,
+      options: { bubbles: false },
+    },
+    // @ts-expect-error false 字段不要写 默认false
+    error4: {
+      detailType: Boolean,
+      options: { capturePhase: false },
+    },
+    // @ts-expect-error composed字段不可以单独开启,必须存在 bubbles或capturePhase字段为true时
+    error5: {
+      detailType: Boolean,
+      options: { composed: true },
+    },
+  },
+});
+
+/**
+ * 2 重复字段
+ */
+RootComponent()({
+  events: {
+    aaa() {
+      1;
+    },
+  },
+  customEvents: {
+    // @ts-expect-error  "⚠️与events字段重复⚠️"
+    aaa: String,
+  },
+});
+
+/**
+ * 3.1 非法字段验证
+ */
+RootComponent()({
+  customEvents: {
+    error1: {
+      detailType: String,
+      options: {
+        bubbles: true,
+        // @ts-expect-error 非法字段  composed 少了d
+        compose: true,
+      },
+    },
+  },
+});
+
+/**
+ * 3.2 非法字段验证
+ */
+RootComponent()({
+  customEvents: {
+    error2: {
+      detailType: String,
+      options: {
+        bubbles: true,
+        // @ts-expect-error 非法字段  capturePhases 多了 s
+        capturePhases: true,
+      },
+    },
+  },
+});
+
+/**
+ * 4 重复字段与非法同时存在时 只报其一错误(非法),确保报错位置在字段而非customEvents位置。
+ */
+RootComponent()({
+  events: {
+    aaa() {
+      1;
+    },
+  },
+  customEvents: {
+    bbb: {
+      detailType: null,
+      options: {
+        // @ts-expect-error 非法字段
+        bubbleds: false,
+      },
+    },
+    aaa: String,
+  },
+});

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

@@ -0,0 +1,92 @@
+import { Checking, type Test } from "hry-types";
+import { RootComponent, type SpecificType } from "../../../..";
+import type { CustomEventConstraint, FullCustomEvents, ShortCustomeEvents } from "../CustomEventConstraint";
+import type {
+  Bubbles,
+  BubblesCapture,
+  BubblesCaptureComposed,
+  BubblesComposed,
+  Capture,
+  CaptureComposed,
+} from "../CustomEventsTag";
+
+/**
+ * customEvents字段简写配置
+ */
+export const mock_shortCustomEvents = {
+  str: String,
+  null: null,
+  unionStr: String as SpecificType<"male" | "female">,
+  union: [String, Number as SpecificType<0 | 1 | 2>, null],
+} satisfies Record<string, ShortCustomeEvents>;
+
+/**
+ * customEvents字段带options配置
+ */
+export const mock_fullCustomEvents = {
+  bubbles: {
+    detailType: String,
+    options: { bubbles: true },
+  },
+  capturePhase: {
+    detailType: null,
+    options: { capturePhase: true },
+  },
+  bubbles_capturePhase: {
+    detailType: [String, Number],
+    options: { bubbles: true, capturePhase: true },
+  },
+  bubbles_composed: {
+    detailType: String as SpecificType<"male" | "female">,
+    options: { bubbles: true, composed: true },
+  },
+  capturePhase_composed: {
+    detailType: [String, Number as SpecificType<0 | 1 | 2>, null],
+    options: { capturePhase: true, composed: true },
+  },
+  bubbles_capturePhase_composed: {
+    detailType: Boolean,
+    options: { bubbles: true, capturePhase: true, composed: true },
+  },
+} satisfies Record<string, FullCustomEvents>;
+
+export const mock_customEvents = {
+  ...mock_shortCustomEvents,
+  ...mock_fullCustomEvents,
+} satisfies CustomEventConstraint;
+
+const rootDoc = RootComponent()({
+  customEvents: mock_customEvents,
+});
+
+type RootDoc = {
+  customEvents: {
+    // 简写字段 即类型为事件参数e对象的detail字段类型
+    str: string;
+    null: null;
+    unionStr: "male" | "female";
+    union: string | 0 | 1 | 2 | null;
+    // 带options字段 通过联合类型加入。
+    bubbles: string | Bubbles;
+    capturePhase: null | Capture;
+    bubbles_capturePhase: string | number | BubblesCapture;
+    bubbles_composed: "male" | "female" | BubblesComposed;
+    capturePhase_composed: string | 0 | 1 | 2 | null | CaptureComposed;
+    bubbles_capturePhase_composed: boolean | BubblesCaptureComposed;
+  };
+};
+
+// 1 RootDoc中customEventsDoc 类型为事件参数e的detail类型和事件标记的联合(冒泡|穿透|捕获)
+Checking<typeof rootDoc, RootDoc, Test.Pass>;
+
+const rootDocEmpty = RootComponent()({
+  customEvents: {},
+});
+
+// 2. customEvents字段配置为`{}`时,Doc中无customEvents字段
+Checking<typeof rootDocEmpty, {}, Test.Pass>;
+
+const rootDocNoFields = RootComponent()({});
+
+// 3. 无customEvents字段时,Doc中无customEvents字段
+Checking<typeof rootDocNoFields, {}, Test.Pass>;

package/src/api/RootComponent/Data/DataOption.ts

@@ -0,0 +1,19 @@
+import type { V } from "hry-types";
+
+export type DataOption<TData extends object, TProperties> = {
+  /**
+   * 可通过函数返回形式引入基于Mobx的响应式数据
+   * @example
+   * ```ts
+   * {
+   *   //...
+   *   data:{
+   *     reactive_user:() => UserStore.user
+   *   }
+   * }
+   * ```
+   */
+  data?:
+    & TData
+    & V.DuplicateFieldValidator<TData, keyof TProperties, "与properties字段重复">;
+};

package/src/api/RootComponent/Data/GetDataDoc.ts

@@ -0,0 +1,25 @@
+import type { O } from "hry-types";
+import type { IfExtends } from "hry-types/src/Any/IfExtends";
+import type { Func } from "hry-types/src/Misc/Func";
+
+/**
+ * 获取data字段文档类型
+ * @param TData - `DataConstraint`
+ * @param Type - "去掉函数字段" | "返回函数字段" | "函数值类型变为函数返回类型"
+ * @returns object
+ */
+export type GetDataDoc<
+  TData extends object,
+  Type extends "去掉函数字段" | "返回函数字段" | "函数值类型变为函数返回类型" = "函数值类型变为函数返回类型",
+> = IfExtends<
+  Type,
+  "函数值类型变为函数返回类型",
+  O.ReturnTypeInObject<TData>,
+  IfExtends<
+    Type,
+    "去掉函数字段",
+    O.Filter<TData, Func>,
+    // "返回函数字段"
+    O.Select<TData, Func>
+  >
+>;

package/src/api/RootComponent/Data/expected/error.ts

@@ -0,0 +1,14 @@
+import { RootComponent } from "../..";
+
+/**
+ * 1 与properties字段重复
+ */
+RootComponent()({
+  properties: {
+    aaa: String,
+  },
+  data: {
+    // @ts-expect-error ⚠️与properties字段重复⚠️
+    aaa: 123,
+  },
+});

package/src/api/RootComponent/Data/expected/normal.ts

@@ -0,0 +1,68 @@
+import { Checking, type Test } from "hry-types";
+
+import type { ReadonlyDeep } from "hry-types/src/Any/_api";
+import { RootComponent } from "../..";
+
+const RootDoc = RootComponent()({
+  data: {
+    gender: <"male" | "female"> "male",
+    num: 123,
+    _innernalFields: false,
+  },
+  methods: {
+    foo() {
+      // 1 this.data 类型检查
+      Checking<typeof this.data, ReadonlyDeep<RootDocExpected>, Test.Pass>;
+    },
+  },
+});
+
+type RootDocExpected = {
+  gender: "male" | "female";
+  num: number;
+  _innernalFields: boolean;
+};
+
+// 2 返回文档中的data字段类型检查
+Checking<typeof RootDoc["data"], RootDocExpected, Test.Pass>;
+
+/**
+ * data字段配置为空对象时
+ */
+const EmptyDataRootDoc = RootComponent()({
+  data: {},
+  methods: {
+    M1() {
+      // 3  this.data为 `{}`类型
+      Checking<typeof this.data, {}, Test.Pass>;
+    },
+  },
+});
+
+// 4  返回文档中无data字段
+Checking<typeof EmptyDataRootDoc, { methods: { M1: () => void } }, Test.Pass>;
+
+/**
+ *   无data字段配置时
+ */
+const noDataRootDoc = RootComponent()({
+  methods: {
+    M1() {
+      // 5 data为空对象时 this.data为{}类型
+      Checking<typeof this.data, {}, Test.Pass>;
+    },
+  },
+});
+
+// 6 返回文档中无data字段
+Checking<typeof noDataRootDoc, { methods: { M1: () => void } }, Test.Pass>;
+
+// 1 如果在组件A构建前初始化A组件的计算属性,可以在A组件并入子组件B时传递给组件B计算属性值,但由于A组件的计算属性可能依赖properties字段,所以B组件的watch字段监控的properties(即A传递的计算属性)是无意义的。
+
+// 2 如果在created字段初始化A组件的计算属性.与上述一样效果
+
+// 3 如果在attached初始化计算属性那么 那么会导致子组件B 接受properties时报警告，因为A组件的计算属性还为生效即为undefined。
+
+// 4 watch 的建立时机问题： 一定是在created之前
+
+// 问题时watch的建立需要计算属性初始化的数据依赖情况。即properties是否被依赖

package/src/api/RootComponent/Data/test/GetDataDoc.test.ts

@@ -0,0 +1,43 @@
+import { Checking, type Test } from "hry-types";
+
+import type { Mock_User } from "../../Properties/test/normalRequired.test";
+import type { GetDataDoc } from "../GetDataDoc";
+
+export const mock_data = {
+  reactiveUser: () => ({} as Mock_User),
+  num: 2,
+  str: "str",
+};
+
+type Test1 = GetDataDoc<typeof mock_data, "函数值类型变为函数返回类型">;
+
+type Test1Expected = { reactiveUser: Mock_User; num: number; str: string };
+
+Checking<Test1, Test1Expected, Test.Pass>;
+
+type Test2 = GetDataDoc<typeof mock_data, "去掉函数字段">;
+
+type Test2Expected = { num: number; str: string };
+
+Checking<Test2, Test2Expected, Test.Pass>;
+
+type Test3 = GetDataDoc<typeof mock_data, "返回函数字段">;
+
+type Test3Expected = { reactiveUser: () => Mock_User };
+
+Checking<Test3, Test3Expected, Test.Pass>;
+
+// 测试空对象
+type Test4 = GetDataDoc<{}, "返回函数字段">;
+
+type Test4Expected = {};
+
+Checking<Test4, Test4Expected, Test.Pass>;
+
+type Test5 = GetDataDoc<{}, "去掉函数字段">;
+
+Checking<Test5, Test4Expected, Test.Pass>;
+
+type Test6 = GetDataDoc<{}, "返回函数字段">;
+
+Checking<Test6, Test4Expected, Test.Pass>;

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

@@ -0,0 +1,14 @@
+import { RootComponent } from "../..";
+
+/**
+ * 1 与properties字段重复
+ */
+RootComponent()({
+  properties: {
+    aaa: String,
+  },
+  data: {
+    // @ts-expect-error ⚠️与properties字段重复⚠️
+    aaa: 123,
+  },
+});

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

@@ -0,0 +1,63 @@
+import { Checking, type Test } from "hry-types";
+
+import type { ReadonlyDeep } from "hry-types/src/Any/_api";
+import { RootComponent } from "../..";
+
+/**
+ * data字段约束为object,函数类型表示引入的响应式字段(mobx)
+ */
+const RootDoc = RootComponent()({
+  data: {
+    gender: <"male" | "female"> "male", // 联合字面量
+    num: 123,
+    _innernalFields: 123, // 内部字段无法在wxml中使用
+  },
+  methods: {
+    foo() {
+      // 1. data配置类型为函数时,this.data中变为函数返回类型
+      Checking<
+        typeof this.data,
+        ReadonlyDeep<{ gender: "male" | "female"; num: number; _innernalFields: number }>,
+        Test.Pass
+      >;
+    },
+  },
+});
+
+type RootDocExpected = {
+  gender: "male" | "female";
+  num: number;
+  _innernalFields: number;
+};
+
+// 2. data配置类型为函数时,dataDoc中变为函数返回类型
+Checking<typeof RootDoc["data"], RootDocExpected, Test.Pass>;
+
+// data为空对象时
+const EmptyDataRootDoc = RootComponent()({
+  data: {},
+  methods: {
+    M1() {
+      // 3.1 data为空对象时 this.data为{}类型
+      Checking<typeof this.data, {}, Test.Pass>;
+    },
+  },
+});
+
+// 3.2 data为空对象时 返回文档中无data字段
+Checking<typeof EmptyDataRootDoc, { methods: { M1: () => void } }, Test.Pass>;
+
+/**
+ *  无data字段时
+ */
+const noDataRootDoc = RootComponent()({
+  methods: {
+    M1() {
+      // 4.1 data为空对象时 this.data为{}类型
+      Checking<typeof this.data, {}, Test.Pass>;
+    },
+  },
+});
+
+// 4.2 data为空对象时 返回文档中无data字段
+Checking<typeof noDataRootDoc, { methods: { M1: () => void } }, Test.Pass>;

package/src/api/RootComponent/Events/EventsConstraint.ts

@@ -0,0 +1,69 @@
+import type { Select } from "hry-types/src/Object/_api";
+import type { Detail, WMBaseEvent } from "../../../types/OfficialTypeAlias";
+import type { ComponentDoc } from "../../DefineComponent/ReturnType/ComponentDoc";
+import type { CustomEventsDoc } from "../CustomEvents/CustomEventsDoc";
+import type {
+  Bubbles,
+  BubblesCaptureComposed,
+  BubblesComposed,
+  Capture,
+  CaptureComposed,
+  CustomEventsTags,
+} from "../CustomEvents/CustomEventsTag";
+
+// 选择冒泡和穿透的事件
+type FilterNormalFields<O extends object> = Select<O, Bubbles | Capture, "contains->">;
+
+// 获取冒泡或捕获的事件
+type GetBubblesOrCaptureEventsFromCompDoc<
+  TComponentDocTuple extends ComponentDoc[],
+  Result extends CustomEventsDoc = {},
+> = TComponentDocTuple extends [infer Head extends ComponentDoc, ...infer Rest extends ComponentDoc[]]
+  ? GetBubblesOrCaptureEventsFromCompDoc<
+    Rest,
+    Result & (FilterNormalFields<Head["customEvents"] & {}>)
+  >
+  : Result;
+
+// 根据value类型 增加key的后缀
+type _AddSuffixForKey<key extends string, Value extends CustomEventsTags> = Value extends BubblesComposed
+  ? `${key}_bubbles` | `${key}_bubbles_catch`
+  : Value extends CaptureComposed ? `${key}_capture` | `${key}_capture_catch`
+  : Value extends BubblesCaptureComposed ? `${key}_bubbles&capture` | `${key}_bubbles&capture_catch`
+  : never;
+
+// 把自定义事件文档类型变为函数类型并加入后缀
+type TransformCustomEventsDocTypeToFunctionTypeAndAddSuffix<T extends CustomEventsDoc> = {
+  [
+    k in keyof T as _AddSuffixForKey<k & string, Extract<T[k], CustomEventsTags>>
+  ]?: (
+    detail: Detail<
+      Exclude<
+        T[k],
+        CustomEventsTags
+      >
+    >,
+  ) => void;
+};
+
+// 所有子组件自定义事件(过滤掉非冒泡或捕获)的key加入后缀并把值(detailType)转换为函数类型
+type GetAllSubCustomEventsConstraint<TReceivedComponentDoc extends ComponentDoc[] | ComponentDoc> = {} extends
+  TReceivedComponentDoc ? {}
+  : TReceivedComponentDoc extends ComponentDoc[] ? TransformCustomEventsDocTypeToFunctionTypeAndAddSuffix<
+      GetBubblesOrCaptureEventsFromCompDoc<TReceivedComponentDoc>
+    >
+  : ComponentDoc["customEvents"] & {};
+
+/**
+ * events字段约束
+ */
+export type EventsConstraint<TReceivedComponentDoc extends ComponentDoc[] | ComponentDoc = {}> = {} extends
+  TReceivedComponentDoc ? Record<string, (e: WMBaseEvent) => any>
+  : TReceivedComponentDoc extends ComponentDoc ? {
+      [k in keyof TReceivedComponentDoc["customEvents"]]?: (
+        e: Exclude<TReceivedComponentDoc["customEvents"][k], CustomEventsTags>,
+      ) => void;
+    }
+  : GetAllSubCustomEventsConstraint<TReceivedComponentDoc>;
+// // 一般事件字段约束
+// & Record<string, (e: WMBaseEvent) => any>;

package/src/api/RootComponent/Events/EventsOption.ts

@@ -0,0 +1,7 @@
+import type { V } from "hry-types";
+
+export type EventsOption<TEvents extends object, EventsDoc> = {
+  events?:
+    & TEvents
+    & V.IllegalFieldValidator<TEvents, keyof EventsDoc>;
+};