annil 1.0.0

package/src/api/RootComponent/Properties/expected/normalOptional.ts

@@ -0,0 +1,136 @@
+import { Checking, type Test } from "hry-types";
+import type { ReadonlyDeep } from "hry-types/src/Any/_api";
+import type { SpecificType } from "../../../../types/SpecificType";
+import { RootComponent } from "../..";
+import { type Mock_User } from "./normalRequired";
+
+/**
+ * 1 组件实例 properties字段选传类型配置  类型为[OptionalType](../PropertiesConstraint.ts)
+ */
+const OptionalDoc = RootComponent()({
+  properties: {
+    optional_num: { // 普通类型
+      type: Number,
+      value: 123,
+    },
+    optional_gender: {
+      type: String as SpecificType<"male" | "female">, // 同类字面量联合类型
+      value: "male",
+    },
+    optional_tuple: {
+      type: Array as unknown as SpecificType<[number, string, boolean]>, // 元组类型
+      value: [1, "a", true] as [number, string, boolean],
+    },
+    optional_obj: {
+      type: Object as SpecificType<Mock_User>, // 对象类型
+      value: {
+        id: "id",
+        age: 20,
+      },
+    },
+    optional_objOrNull: {
+      type: Object as SpecificType<Mock_User | null>,
+      value: null,
+    },
+    optional_union: { // 非同类联合类型 string | number
+      type: String,
+      value: "string",
+      optionalTypes: [Number],
+    },
+  },
+  methods: {
+    foo() {
+      // 2. 内部this.data中的类型(去除可选)
+      Checking<
+        typeof this.data,
+        ReadonlyDeep<{
+          optional_num: number;
+          optional_gender: "male" | "female";
+          optional_tuple: [number, string, boolean];
+          optional_obj: Mock_User | null;
+          optional_objOrNull: Mock_User | null;
+          optional_union: string | number;
+        }>,
+        Test.Pass
+      >;
+    },
+  },
+});
+
+type OptionalDocExpected = {
+  // 3. 预期返回类型 key为可选(带`?`)
+
+  optional_num?: number;
+  optional_gender?: "male" | "female";
+  optional_tuple?: [number, string, boolean];
+  optional_obj?: Mock_User | null;
+  optional_objOrNull?: Mock_User | null;
+  optional_union?: string | number;
+};
+
+Checking<typeof OptionalDoc["properties"], OptionalDocExpected, Test.Pass>;
+
+// 页面实例 可选对象不加null
+const OptionalDocWhenIsPage = RootComponent()({
+  isPage: true,
+  properties: {
+    optional_num: { // 普通类型
+      type: Number,
+      value: 123,
+    },
+    optional_gender: {
+      type: String as SpecificType<"male" | "female">, // 同类字面量联合类型
+      value: "male",
+    },
+    optional_tuple: {
+      type: Array as unknown as SpecificType<[number, string, boolean]>, // 元组类型
+      value: [1, "a", true] as [number, string, boolean],
+    },
+    optional_obj: {
+      type: Object as SpecificType<Mock_User>, // 对象类型
+      value: {
+        id: "id",
+        age: 20,
+      },
+    },
+    optional_objOrNull: {
+      type: Object as SpecificType<Mock_User | null>,
+      value: null,
+    },
+    optional_union: { // 非同类联合类型 string | number
+      type: String,
+      value: "string",
+      optionalTypes: [Number],
+    },
+  },
+  methods: {
+    foo() {
+      // 2. 内部this.data中的类型(去除可选)
+      Checking<
+        typeof this.data,
+        ReadonlyDeep<{
+          optional_num: number;
+          optional_gender: "male" | "female";
+          optional_tuple: [number, string, boolean];
+          optional_obj: Mock_User; // 不格外添加 Null
+          optional_objOrNull: Mock_User | null; // 本身待的null 非格外添加
+          optional_union: string | number;
+        }>,
+        Test.Pass
+      >;
+    },
+  },
+});
+
+type OptionalDocWhenIsPageExpected = {
+  // 3. 预期返回类型 key为可选(带`?`)
+
+  optional_num?: number;
+  optional_gender?: "male" | "female";
+  optional_tuple?: [number, string, boolean];
+  optional_obj?: Mock_User; // 不格外添加 Null
+  optional_objOrNull?: Mock_User | null; // 本身待的null 非格外添加
+  optional_union?: string | number;
+};
+
+Checking<typeof OptionalDocWhenIsPage["properties"], OptionalDocWhenIsPageExpected, Test.Pass>;

package/src/api/RootComponent/Properties/expected/normalRequired.ts

@@ -0,0 +1,100 @@
+import { Checking, type Test } from "hry-types";
+import type { SpecificType } from "../../../../types/SpecificType";
+
+import type { ReadonlyDeep } from "hry-types/src/Any/_api";
+import { RootComponent } from "../..";
+import type { RequiredSingle, RequiredType, RequiredUnion } from "../PropertiesConstraint";
+
+/**
+ * 公共测试对象类型
+ */
+export type Mock_User = {
+  id: string;
+  age?: number;
+};
+
+/**
+ * 公共测试对象类型
+ */
+export type Mock_Cart = {
+  id: string;
+  selectedCount: number;
+};
+
+/**
+ *  properties 必传单一类型配置
+ */
+export const mock_requiredSingle = {
+  str: String,
+  num: Number,
+  bool: Boolean,
+  arr: Array,
+  obj: Object,
+  tuple: Array as unknown as SpecificType<[string, number, boolean]>,
+  union_str: String as SpecificType<"male" | "female">,
+  union_num: Number as SpecificType<0 | 1 | 2>,
+  union_bool: Boolean as SpecificType<false | true>,
+  union_arr: Array as SpecificType<number[] | string[]>,
+  union_obj: Object as SpecificType<Mock_User | Mock_Cart>,
+} satisfies Record<string, RequiredSingle>;
+
+/**
+ * properties 必传联合类型配置
+ */
+export const mock_requiredUnion = {
+  union_str_num_bool: {
+    type: String,
+    optionalTypes: [Number, Boolean],
+  },
+  union_literalStr_Literalnum: {
+    type: String as SpecificType<"male" | "female">,
+    optionalTypes: [Number as SpecificType<0 | 1 | 2>],
+  },
+  union_mockUser_num: {
+    type: Object as SpecificType<Mock_User>,
+    optionalTypes: [Number],
+  },
+  union_num_mockUser: {
+    type: Number,
+    optionalTypes: [Object as SpecificType<Mock_User>],
+  },
+} satisfies Record<string, RequiredUnion>;
+
+/**
+ * properties 必传字段全配置(单一类型 + 联合类型)
+ */
+export const mock_requiredTypes = {
+  ...mock_requiredSingle,
+  ...mock_requiredUnion,
+} satisfies Record<string, RequiredType>;
+
+type RequiredTypeExpected = {
+  str: string;
+  num: number;
+  bool: boolean;
+  arr: unknown[];
+  obj: object | null;
+  tuple: [string, number, boolean];
+  union_str: "male" | "female";
+  union_num: 0 | 1 | 2;
+  union_bool: boolean;
+  union_arr: number[] | string[];
+  union_obj: Mock_User | Mock_Cart | null;
+  union_str_num_bool: string | number | boolean;
+  union_literalStr_Literalnum: 0 | 1 | 2 | "male" | "female";
+  union_mockUser_num: number | Mock_User | null;
+  union_num_mockUser: number | Mock_User | null;
+};
+
+const RequiredDoc = RootComponent()({
+  properties: mock_requiredTypes,
+  methods: {
+    foo() {
+      // 1 this.data中的类型(对象类型加null)
+      Checking<typeof this.data, ReadonlyDeep<RequiredTypeExpected>, Test.Pass>;
+    },
+  },
+});
+
+// 2 properties文档类型中对象类型加入null(与this.data一致)
+Checking<typeof RequiredDoc["properties"], RequiredTypeExpected, Test.Pass>;

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

@@ -0,0 +1,49 @@
+import { RootComponent, type SpecificType } from "../../../../index";
+import type { Mock_Cart } from "./normalRequired.test";
+
+// 1 非法字段
+RootComponent()({
+  properties: {
+    num: {
+      type: Number,
+      // @ts-expect-error   非法字段 values多了`s`
+      values: 123,
+    },
+    bool: {
+      type: Boolean,
+      value: true,
+      // @ts-expect-error   非法字段 optionalType少了`s`
+      optionalType: [String],
+    },
+    union: {
+      type: Number,
+      value: 123,
+      optionalTypes: [String],
+      // @ts-expect-error   非法字段 observable
+      observable: "",
+    },
+  },
+});
+
+// 2 value 类型错误
+RootComponent()({
+  properties: {
+    str: {
+      type: String,
+      // @ts-expect-error 类型错误
+      value: 123,
+    },
+    optionalObj: {
+      // @ts-expect-error 对象默认值要写null则必须先定义
+      type: Object as SpecificType<Mock_Cart>,
+      // @ts-expect-error 对象默认值要写null则必须先定义
+      value: null,
+    },
+    str_num: {
+      type: String,
+      // @ts-expect-error 类型错误 应该写type字段类型(string)而非optionalTypes中的类型
+      value: 123,
+      optionalTypes: [Number],
+    },
+  },
+});

package/src/api/RootComponent/Properties/test/normalEmpty.test..ts

@@ -0,0 +1,41 @@
+import { Checking, type Test } from "hry-types";
+import { RootComponent } from "../..";
+
+/**
+ * Properties配置为`{}`时
+ */
+const emptyObj = RootComponent()({
+  properties: {},
+  methods: {
+    foo() {
+      // 1 this.data 为空对象类型
+      Checking<typeof this.data, {}, Test.Pass>;
+    },
+  },
+});
+
+// 2 返回文档类型无properties字段
+Checking<typeof emptyObj, {
+  methods: {
+    foo(): void;
+  };
+}, Test.Pass>;
+
+/**
+ * 无Properties配置时
+ */
+const noProperties = RootComponent()({
+  methods: {
+    foo() {
+      // 3 this.data 为空对象类型
+      Checking<typeof this.data, {}, Test.Pass>;
+    },
+  },
+});
+
+// 4 返回文档类型无properties字段
+Checking<typeof noProperties, {
+  methods: {
+    foo(): void;
+  };
+}, Test.Pass>;

package/src/api/RootComponent/Properties/test/normalOptional.test.ts

@@ -0,0 +1,75 @@
+import { Checking, type Test } from "hry-types";
+import type { ReadonlyDeep } from "hry-types/src/Any/_api";
+import type { SpecificType } from "../../../../types/SpecificType";
+import { RootComponent } from "../..";
+import { type Mock_User } from "./normalRequired.test";
+
+/**
+ * properties字段选传类型配置  类型为[OptionalType](../PropertiesConstraint.ts)
+ */
+const OptionalDoc = RootComponent()({
+  properties: {
+    optional_num: { // 普通类型
+      type: Number,
+      value: 123,
+    },
+    optional_gender: {
+      type: String as SpecificType<"male" | "female">, // 同类字面量联合类型
+      value: "male",
+    },
+    optional_tuple: {
+      type: Array as unknown as SpecificType<[number, string, boolean]>, // 元组类型
+      value: [1, "a", true] as [number, string, boolean],
+    },
+    optional_obj: {
+      type: Object as SpecificType<Mock_User>, // 对象类型
+      value: {
+        id: "id",
+        age: 20,
+      },
+    },
+    optional_objOrNull: {
+      type: Object as SpecificType<Mock_User | null>, // 对象类型与null的联合
+      value: null,
+    },
+    optional_union: { // 非同类联合类型 string | number
+      type: String,
+      value: "string",
+      optionalTypes: [Number],
+    },
+  },
+  methods: {
+    foo() {
+      // 1. 内部this.data中的类型(去除可选)
+      Checking<
+        typeof this.data,
+        ReadonlyDeep<{
+          optional_num: number;
+          optional_gender: "male" | "female";
+          optional_tuple: [number, string, boolean];
+          optional_obj: Mock_User | null;
+          optional_objOrNull: Mock_User | null;
+          optional_union: string | number;
+        }>,
+        Test.Pass
+      >;
+    },
+  },
+});
+
+type OptionalDocExpected = {
+  // 2. 预期返回类型 key为可选(带`?`)
+  properties: {
+    optional_num?: number;
+    optional_gender?: "male" | "female";
+    optional_tuple?: [number, string, boolean];
+    optional_obj?: Mock_User | null;
+    optional_objOrNull?: Mock_User | null;
+    optional_union?: string | number;
+  };
+  methods: {
+    foo(): void;
+  };
+};
+
+Checking<typeof OptionalDoc, OptionalDocExpected, Test.Pass>;

package/src/api/RootComponent/Properties/test/normalRequired.test.ts

@@ -0,0 +1,106 @@
+import { Checking, type Test } from "hry-types";
+import type { SpecificType } from "../../../../types/SpecificType";
+
+import type { ReadonlyDeep } from "hry-types/src/Any/_api";
+import { RootComponent } from "../..";
+import type { RequiredSingle, RequiredType, RequiredUnion } from "../PropertiesConstraint";
+
+/**
+ * 共用测试对象类型
+ */
+export type Mock_User = {
+  id: string;
+  age?: number;
+};
+
+/**
+ * 共用测试对象类型
+ */
+export type Mock_Cart = {
+  id: string;
+  selectedCount: number;
+};
+
+/**
+ *  properties 必传单一类型配置
+ */
+export const mock_requiredSingle = {
+  str: String,
+  num: Number,
+  bool: Boolean,
+  arr: Array,
+  obj: Object,
+  tuple: Array as unknown as SpecificType<[string, number, boolean]>,
+  union_str: String as SpecificType<"male" | "female">,
+  union_num: Number as SpecificType<0 | 1 | 2>,
+  union_bool: Boolean as SpecificType<false | true>,
+  union_arr: Array as SpecificType<number[] | string[]>,
+  union_obj: Object as SpecificType<Mock_User | Mock_Cart>,
+} satisfies Record<string, RequiredSingle>;
+
+/**
+ * properties 必传联合类型配置
+ */
+export const mock_requiredUnion = {
+  union_str_num_bool: {
+    type: String,
+    optionalTypes: [Number, Boolean],
+  },
+  union_literalStr_Literalnum: {
+    type: String as SpecificType<"male" | "female">,
+    optionalTypes: [Number as SpecificType<0 | 1 | 2>],
+  },
+  union_mockUser_num: {
+    type: Object as SpecificType<Mock_User>,
+    optionalTypes: [Number],
+  },
+  union_num_mockUser: {
+    type: Number,
+    optionalTypes: [Object as SpecificType<Mock_User>],
+  },
+} satisfies Record<string, RequiredUnion>;
+
+/**
+ * properties 必传字段全配置(单一类型 + 联合类型)
+ */
+export const mock_requiredTypes = {
+  ...mock_requiredSingle,
+  ...mock_requiredUnion,
+} satisfies Record<string, RequiredType>;
+
+type RequiredTypeExpected = {
+  str: string;
+  num: number;
+  bool: boolean;
+  arr: unknown[];
+  obj: object | null;
+  tuple: [string, number, boolean];
+  union_str: "male" | "female";
+  union_num: 0 | 1 | 2;
+  union_bool: boolean;
+  union_arr: number[] | string[];
+  union_obj: Mock_User | Mock_Cart | null;
+  union_str_num_bool: string | number | boolean;
+  union_literalStr_Literalnum: 0 | 1 | 2 | "male" | "female";
+  union_mockUser_num: number | Mock_User | null;
+  union_num_mockUser: number | Mock_User | null;
+};
+
+const RequiredDoc = RootComponent()({
+  properties: mock_requiredTypes,
+  methods: {
+    foo() {
+      // 1 this.data中的类型(对象类型加null)
+      Checking<typeof this.data, ReadonlyDeep<RequiredTypeExpected>, Test.Pass>;
+    },
+  },
+});
+/**
+ * 2 properties配置为必传类型时预期文档类型(与this.data一致)
+ */
+export type RequiredDocExpected = {
+  properties: RequiredTypeExpected;
+  methods: { foo: () => void };
+};
+
+Checking<typeof RequiredDoc, RequiredDocExpected, Test.Pass>;

package/src/api/RootComponent/RootComponentDoc.ts

@@ -0,0 +1,38 @@
+import type { Func } from "hry-types/src/Misc/Func";
+import type { WMCompPageLifetimes, WMPageLifetimes } from "../../types/OfficialTypeAlias";
+import type { LifetimesConstraint } from "./Lifetimes/LifetimesConstraint";
+
+type _RootComponentDoc = {
+  isPage?: boolean;
+  properties?: object;
+  data?: object;
+  computed?: object;
+  customEvents?: object;
+  methods?: object;
+  events?: object;
+  store?: object;
+  watch?: Record<string, Func>;
+  lifetimes?: LifetimesConstraint;
+  pageLifetimes?: Partial<WMCompPageLifetimes & { load: Func } & WMPageLifetimes>;
+};
+
+// 验证key是否合法
+type _Validator<O, ErrKeys = Exclude<keyof O, keyof _RootComponentDoc>> = [ErrKeys] extends [never] ? _RootComponentDoc
+  : `错误的字段${ErrKeys & string}`;
+
+/**
+ * RootComponent Api 返回的类型
+ * ```ts
+ * RootComponentDoc = {
+ * isPage?: true;
+ * properties?: object;
+ * data?: object;
+ * store?:object;
+ * computed?: object;
+ * customEvents?: object;
+ * methods?: object;
+ * events?: object;
+ * };
+ * ```
+ */
+export type RootComponentDoc<O extends _Validator<O> = _RootComponentDoc> = O;

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

@@ -0,0 +1,3 @@
+import type { StoreConstraint } from "./StoreConstraint";
+
+export type GeTStoreDoc<TStore extends StoreConstraint> = { [k in keyof TStore]: ReturnType<TStore[k]> };

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

@@ -0,0 +1 @@
+export type StoreConstraint = Record<string, () => unknown>;

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

@@ -0,0 +1,8 @@
+import type { V } from "hry-types";
+import type { StoreConstraint } from "./StoreConstraint";
+
+export type StoreOption<TStore extends StoreConstraint, TDuplicate extends object> = {
+  store?:
+    & TStore
+    & V.DuplicateFieldValidator<TStore, keyof TDuplicate, "字段重复">;
+};

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

@@ -0,0 +1,30 @@
+import { observable } from "mobx";
+import { RootComponent } from "../..";
+const user = observable({
+  name: "zhao",
+  age: 20,
+});
+
+// 约束错误
+RootComponent()({
+  store: {
+    // @ts-expect-error 不能将类型“string”分配给类型“() => unknown”
+    userName: user.name,
+  },
+});
+
+// 重复字段错误
+RootComponent()({
+  properties: {
+    userName: String,
+  },
+  data: {
+    userAge: 20,
+  },
+  store: {
+    // @ts-expect-error 1 与properties字段重复
+    userName: () => user.name,
+    // @ts-expect-error 2 与userAge字段重复
+    userAge: () => user.age,
+  },
+});

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

@@ -0,0 +1,13 @@
+import { observable } from "mobx";
+import { RootComponent } from "../..";
+const user = observable({
+  name: "zhao",
+  age: 20,
+});
+
+RootComponent()({
+  store: {
+    userName: () => user.name,
+    userAge: () => user.age,
+  },
+});

package/src/api/RootComponent/Watch/WatchOption.ts

@@ -0,0 +1,64 @@
+import type { ReadonlyDeep } from "hry-types/src/Any/_api";
+import type { IfExtends } from "hry-types/src/Any/IfExtends";
+import type { IsPureObject } from "hry-types/src/Any/IsPureObject";
+import type { NoInfer } from "hry-types/src/Generic/NoInfer";
+import type { EmptyObject } from "hry-types/src/Misc/EmptyObject";
+
+type getFirstKeys<T extends string> = T extends `${infer F}.${string}` ? F : never;
+
+type getLastKeys<T extends string> = T extends `${string}.${infer L}` ? L : never;
+
+// 加入对象字段一级key 例如 `obj.xxx`(newValue,oldValue){...}
+type AddFieldsOfObject<
+  TWatchData extends object,
+  _WatchKeys extends keyof TWatchData,
+  secondKeys extends string = {
+    [k in _WatchKeys]: IsPureObject<Exclude<TWatchData[k], null>> extends true
+      ? `${k & string}.${(keyof Exclude<TWatchData[k], null>) & string}`
+      : never;
+  }[_WatchKeys],
+> =
+  & {
+    // 添加对象类型.keys
+    [
+      k in _WatchKeys as IsPureObject<Exclude<TWatchData[k], null>> extends true
+        ? `${k & string}.${(keyof Exclude<TWatchData[k], null>) & string}`
+        : never
+    ]?: unknown;
+  }
+  & {
+    [k in secondKeys]?: (
+      // @ts-ignore
+      newValue: ReadonlyDeep<(Exclude<TWatchData[getFirstKeys<k>], null>)[getLastKeys<k>] & {}>,
+      // @ts-ignore
+      oldValue: ReadonlyDeep<(Exclude<TWatchData[getFirstKeys<k>], null>)[getLastKeys<k>]>,
+    ) => void;
+  };
+
+export type WatchOption<TWatchData extends object, _WatchKeys extends keyof TWatchData = keyof TWatchData> = {
+  /**
+   * 监控所有data字段,值变化时(JSON.stringify判断)运行watch函数,一参为最新值,二参为变化前值。
+   * 对象数据可通过`obj.xxx:`监控具体字段(只加入了一级字段类型提示)
+   */
+  watch?: IfExtends<
+    {},
+    TWatchData,
+    EmptyObject,
+    // 不加NoInfer会导致只监控计算字段时错误
+    NoInfer<
+      & {
+        [k in _WatchKeys]?: (
+          // newValue 去除null 深度只读
+          newValue: ReadonlyDeep<Exclude<TWatchData[k], null>>,
+          oldValue: ReadonlyDeep<TWatchData[k]>,
+        ) => void;
+      }
+      // 解决单独书写计算书写字段的报错(猜测是:ts字面量约束检测提前计算属性key引起的错误提示)
+      & {
+        [k in _WatchKeys as never]: unknown;
+      }
+      // 加入对象的一级字段类型提示
+      & AddFieldsOfObject<TWatchData, _WatchKeys>
+    >
+  >;
+};