annil 1.0.4 → 1.0.6

package/src/api/RootComponent/Instance/test/CustomEventsDoc.test.ts

@@ -1,40 +1,40 @@
 import { Checking, type Test } from "hry-types";
-import type { SpecificType } from "../../../..";
+import type { DetailedType } from "../../../..";
 import { RootComponent } from "../..";
 RootComponent()({
   customEvents: {
     str: String,
-    num: Number as SpecificType<1 | 2>,
-    union: [String as SpecificType<"male" | "femal">, Number],
+    num: Number as DetailedType<1 | 2>,
+    union: [String as DetailedType<"male" | "femal">, Number],
     null: null,
     bubbles: {
-      detailType: String,
+      detail: String,
       options: {
         bubbles: true,
       },
     },
     capturePhase: {
-      detailType: Number,
+      detail: Number,
       options: {
         capturePhase: true,
       },
     },
     bubblesComposed: {
-      detailType: Number,
+      detail: Number,
       options: {
         bubbles: true,
         composed: true,
       },
     },
     capturePhaseComposed: {
-      detailType: Number,
+      detail: Number,
       options: {
         capturePhase: true,
         composed: true,
       },
     },
     bubblesCapturePhaseComposed: {
-      detailType: null,
+      detail: null,
       options: {
         bubbles: true,
         capturePhase: true,

package/src/api/RootComponent/Instance/test/customEvents/normal.test.ts

@@ -1,41 +1,41 @@
 import { Checking, type Test } from "hry-types";
-import type { SpecificType } from "../../../../..";
+import type { DetailedType } from "../../../../..";
 import { RootComponent } from "../../..";
 
 RootComponent()({
   customEvents: {
     str: String,
-    num: Number as SpecificType<1 | 2>,
-    union: [String as SpecificType<"male" | "femal">, Number],
+    num: Number as DetailedType<1 | 2>,
+    union: [String as DetailedType<"male" | "femal">, Number],
     null: null,
     bubbles: {
-      detailType: String,
+      detail: String,
       options: {
         bubbles: true,
       },
     },
     capturePhase: {
-      detailType: Number,
+      detail: Number,
       options: {
         capturePhase: true,
       },
     },
     bubblesComposed: {
-      detailType: Number,
+      detail: Number,
       options: {
         bubbles: true,
         composed: true,
       },
     },
     capturePhaseComposed: {
-      detailType: Number,
+      detail: Number,
       options: {
         capturePhase: true,
         composed: true,
       },
     },
     bubblesCapturePhaseComposed: {
-      detailType: null,
+      detail: null,
       options: {
         bubbles: true,
         capturePhase: true,

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

@@ -1,13 +1,13 @@
 import { Checking, type Test } from "hry-types";
 import type { ReadonlyDeep } from "hry-types/src/Any/ReadonlyDeep";
-import { RootComponent, type SpecificType } from "../../../../..";
+import { type DetailedType, RootComponent } from "../../../../..";
 
 // 组件时
 RootComponent()({
   properties: {
     obj: Object,
     optionalObj: {
-      type: Object as SpecificType<{ name: string }>,
+      type: Object as DetailedType<{ name: string }>,
       value: { name: "zhao" },
     },
   },
@@ -25,7 +25,7 @@ RootComponent()({
   properties: {
     obj: Object,
     optionalObj: {
-      type: Object as SpecificType<{ name: string }>,
+      type: Object as DetailedType<{ name: string }>,
       value: { name: "zhao" },
     },
   },

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

@@ -1,5 +1,5 @@
 import { Checking, type Test } from "hry-types";
-import { RootComponent, type SpecificType } from "../../../..";
+import { type DetailedType, RootComponent } from "../../../..";
 
 import type { RemoveNullOfRequired } from "../../../../types/RemoveNullOfRequired";
 import type { Mock_User } from "../../Properties/test/normalRequired.test";
@@ -29,11 +29,11 @@ RootComponent()({
     str: String,
     obj: Object,
     union: {
-      type: Object as SpecificType<Mock_User>,
+      type: Object as DetailedType<Mock_User>,
       value: { id: "001", name: "zhao" },
     },
     optionalObject: {
-      type: Object as SpecificType<Mock_User | null>,
+      type: Object as DetailedType<Mock_User | null>,
       value: null,
     },
   },

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

@@ -1,7 +1,7 @@
 import type { IfExtends } from "hry-types/src/Any/IfExtends";
 import type { Select } from "hry-types/src/Object/Select";
 import type { AddNullForObject } from "../../../types/AddNullForObject";
-import type { InferSpecificType } from "../../../types/InferSpecificType";
+import type { InferDetailedType } from "../../../types/InferDetailedType";
 import type { OptionalType, PropertiesConstraint } from "./PropertiesConstraint";
 
 /**
@@ -20,19 +20,19 @@ export type GetOptionalDoc<
       false,
       TIsPage,
       // 组件时 对象加null
-      AddNullForObject<InferSpecificType<Optional[k]["type"]>>,
+      AddNullForObject<InferDetailedType<Optional[k]["type"]>>,
       // 页面时 对象不加
-      InferSpecificType<Optional[k]["type"]>
+      InferDetailedType<Optional[k]["type"]>
     >,
     IfExtends<
       false,
       TIsPage,
       // 组件时 对象加null
       AddNullForObject<
-        InferSpecificType<Optional[k]["type"]> | InferSpecificType<(Optional[k]["optionalTypes"] & {})[number]>
+        InferDetailedType<Optional[k]["type"]> | InferDetailedType<(Optional[k]["optionalTypes"] & {})[number]>
       >,
       // 页面时 对象不加
-      InferSpecificType<Optional[k]["type"]> | InferSpecificType<(Optional[k]["optionalTypes"] & {})[number]>
+      InferDetailedType<Optional[k]["type"]> | InferDetailedType<(Optional[k]["optionalTypes"] & {})[number]>
     >
   >;
 };

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

@@ -1,7 +1,7 @@
 import type { IfExtends } from "hry-types/src/Any/IfExtends";
 import type { Select } from "hry-types/src/Object/Select";
 
-import type { ComputeIntersection } from "hry-types/src/Object/_api";
+import type { ComputeIntersection, NonReadonlyDeep } from "hry-types/src/Object/_api";
 import type { GetOptionalDoc } from "./GetOptionalDoc";
 import type { GetRequiredDoc } from "./GetRequiredDoc";
 import type { OptionalType, PropertiesConstraint } from "./PropertiesConstraint";
@@ -10,8 +10,8 @@ type _GetPropertiesDoc<
   TProperties extends PropertiesConstraint,
   TIsPage extends boolean,
   Type extends "Required" | "Optional" | "all" = "all",
-  OptionalDoc = GetOptionalDoc<Select<TProperties, OptionalType>, TIsPage>,
-  RequiredDoc = GetRequiredDoc<Omit<TProperties, keyof OptionalDoc>, TIsPage>,
+  OptionalDoc = NonReadonlyDeep<GetOptionalDoc<Select<TProperties, OptionalType>, TIsPage>>,
+  RequiredDoc = NonReadonlyDeep<GetRequiredDoc<Omit<TProperties, keyof OptionalDoc>, TIsPage>>,
 > = IfExtends<
   Type,
   "all",

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

@@ -1,7 +1,7 @@
 import type { IfExtends } from "hry-types/src/Any/IfExtends";
 import type { Select } from "hry-types/src/Object/Select";
 import type { AddNullForObject } from "../../../types/AddNullForObject";
-import type { InferSpecificType } from "../../../types/InferSpecificType";
+import type { InferDetailedType } from "../../../types/InferDetailedType";
 import type { PropertiesConstraint, RequiredSingle, RequiredType } from "./PropertiesConstraint";
 
 /**
@@ -17,16 +17,16 @@ export type GetRequiredDoc<
   [k in keyof Required]: IfExtends<
     Required[k],
     RequiredSingle,
-    IfExtends<false, TIsPage, AddNullForObject<InferSpecificType<Required[k]>>, InferSpecificType<Required[k]>>,
+    IfExtends<false, TIsPage, AddNullForObject<InferDetailedType<Required[k]>>, InferDetailedType<Required[k]>>,
     IfExtends<
       false,
       TIsPage,
       // @ts-ignore Required[k] 必为 RequiredUnion
-      | AddNullForObject<InferSpecificType<Required[k]["type"]>>
+      | AddNullForObject<InferDetailedType<Required[k]["type"]>>
       // @ts-ignore Required[k] 必为 RequiredUnion
-      | AddNullForObject<InferSpecificType<Required[k]["optionalTypes"][number]>>,
+      | AddNullForObject<InferDetailedType<Required[k]["optionalTypes"][number]>>,
       // @ts-ignore Required[k] 必为 RequiredUnion
-      InferSpecificType<Required[k]["type"]> | InferSpecificType<Required[k]["optionalTypes"][number]>
+      InferDetailedType<Required[k]["type"]> | InferDetailedType<Required[k]["optionalTypes"][number]>
     >
   >;
 };

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

@@ -1,38 +1,38 @@
-import type { SpecificType } from "../../../types/SpecificType";
+import type { DetailedType } from "../../../types/DetailedType";
 
 /**
  * properties 必传(单一)类型
  */
-export type RequiredSingle = SpecificType;
+export type RequiredSingle = DetailedType;
 
 /**
  * properties 必传(联合)类型
  */
-export type RequiredUnion<Literal = unknown> = {
-  type: SpecificType<Literal>;
-  optionalTypes: SpecificType[];
+export type RequiredUnion = {
+  type: DetailedType;
+  optionalTypes: DetailedType[];
 };
 
 /**
  * properties 必传类型
  */
-export type RequiredType<Literal = unknown> = RequiredUnion<Literal> | RequiredSingle;
+export type RequiredType = RequiredUnion | RequiredSingle;
 
 /**
  * properties 选传类型
  */
-export type OptionalType<Literal = unknown> = {
-  type: SpecificType<Literal>;
-  value: Literal;
-  optionalTypes?: SpecificType[];
+export type OptionalType = {
+  type: DetailedType;
+  value: unknown;
+  optionalTypes?: DetailedType[];
 };
 
 /**
  * Properties 字段类型
  */
-export type PropertiesTypes<Literal = unknown> = OptionalType<Literal> | RequiredType<Literal>;
+export type PropertiesTypes = OptionalType | RequiredType;
 
 /**
  * RootComponent API properties 字段约束
  */
-export type PropertiesConstraint<Literal = unknown> = Record<string, PropertiesTypes<Literal>>;
+export type PropertiesConstraint = Record<string, PropertiesTypes>;

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

@@ -13,7 +13,7 @@ export type PropertiesOption<
  = // DuplicateFieldCheck extends PropertyKey = "",
   {
     /**
-     * 可通过 as SpecificType<anyType> 书写任意类型
+     * 可通过 as DetailedType<anyType> 书写任意类型
      * @remarks 禁用observable字段,简写或对象写法无value字段时为必传属性(必传对象类型加入null类型),对象写法有value字段为可选属性.
      */
     properties?:

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

@@ -1,5 +1,5 @@
 import type { EmptyObject } from "hry-types/src/Misc/EmptyObject";
-import type { InferSpecificType } from "../../../types/InferSpecificType";
+import type { InferDetailedType } from "../../../types/InferDetailedType";
 
 /**
  * 验证properties的value类型是否正确
@@ -12,7 +12,7 @@ export type PropertiesValueValidator<
       k in keyof TProperties as TProperties[k] extends {
         type: infer R;
         value: infer V;
-      } ? V extends InferSpecificType<R> ? never
+      } ? V extends InferDetailedType<R> ? never
         : k
         : never
     ]: { value: () => "⚠️类型错误⚠️" };

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

@@ -1,4 +1,4 @@
-import { RootComponent, type SpecificType } from "../../../../index";
+import { type DetailedType, RootComponent } from "../../../../index";
 import type { Mock_Cart } from "./normalRequired.test";
 
 // 1 非法字段
@@ -35,7 +35,7 @@ RootComponent()({
     },
     optionalObj: {
       // @ts-expect-error 对象默认值要写null则必须先定义
-      type: Object as SpecificType<Mock_Cart>,
+      type: Object as DetailedType<Mock_Cart>,
       // @ts-expect-error 对象默认值要写null则必须先定义
       value: null,
     },

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

@@ -1,6 +1,6 @@
 import { Checking, type Test } from "hry-types";
 import type { ReadonlyDeep } from "hry-types/src/Any/_api";
-import type { SpecificType } from "../../../../types/SpecificType";
+import type { DetailedType } from "../../../../types/DetailedType";
 import { RootComponent } from "../..";
 import { type Mock_User } from "./normalRequired.test";
 
@@ -14,22 +14,22 @@ const OptionalDoc = RootComponent()({
       value: 123,
     },
     optional_gender: {
-      type: String as SpecificType<"male" | "female">, // 同类字面量联合类型
+      type: String as DetailedType<"male" | "female">, // 同类字面量联合类型
       value: "male",
     },
     optional_tuple: {
-      type: Array as unknown as SpecificType<[number, string, boolean]>, // 元组类型
+      type: Array as unknown as DetailedType<[number, string, boolean]>, // 元组类型
       value: [1, "a", true] as [number, string, boolean],
     },
     optional_obj: {
-      type: Object as SpecificType<Mock_User>, // 对象类型
+      type: Object as DetailedType<Mock_User>, // 对象类型
       value: {
         id: "id",
         age: 20,
       },
     },
     optional_objOrNull: {
-      type: Object as SpecificType<Mock_User | null>, // 对象类型与null的联合
+      type: Object as DetailedType<Mock_User | null>, // 对象类型与null的联合
       value: null,
     },
     optional_union: { // 非同类联合类型 string | number
@@ -74,16 +74,16 @@ type OptionalDocExpected = {
 
 Checking<typeof OptionalDoc, OptionalDocExpected, Test.Pass>;
 
-// properties 使用SpecificType时,接受interface类型
+// properties 使用DetailedType时,接受interface类型
 interface Foo {
   name: string;
 }
 
 RootComponent()({
   properties: {
-    xxx: Object as SpecificType<{ dd: Foo }>,
+    xxx: Object as DetailedType<{ dd: Foo }>,
     user: {
-      type: Object as SpecificType<Foo>,
+      type: Object as DetailedType<Foo>,
       value: { name: "zhao" },
     },
   },
@@ -93,3 +93,17 @@ RootComponent()({
     },
   },
 });
+
+/**
+ * 对象类型字面量类型可验证通过。
+ */
+type obj = { gender: "male" | "femal" };
+
+RootComponent()({
+  properties: {
+    obj: {
+      type: Object as DetailedType<obj>,
+      value: { gender: "male" },
+    },
+  },
+});

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

@@ -1,5 +1,5 @@
 import { Checking, type Test } from "hry-types";
-import type { SpecificType } from "../../../../types/SpecificType";
+import type { DetailedType } from "../../../../types/DetailedType";
 
 import type { ReadonlyDeep } from "hry-types/src/Any/_api";
 import { RootComponent } from "../..";
@@ -30,12 +30,12 @@ export const mock_requiredSingle = {
   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>,
+  tuple: Array as unknown as DetailedType<[string, number, boolean]>,
+  union_str: String as DetailedType<"male" | "female">,
+  union_num: Number as DetailedType<0 | 1 | 2>,
+  union_bool: Boolean as DetailedType<false | true>,
+  union_arr: Array as DetailedType<number[] | string[]>,
+  union_obj: Object as DetailedType<Mock_User | Mock_Cart>,
 } satisfies Record<string, RequiredSingle>;
 
 /**
@@ -47,16 +47,16 @@ export const mock_requiredUnion = {
     optionalTypes: [Number, Boolean],
   },
   union_literalStr_Literalnum: {
-    type: String as SpecificType<"male" | "female">,
-    optionalTypes: [Number as SpecificType<0 | 1 | 2>],
+    type: String as DetailedType<"male" | "female">,
+    optionalTypes: [Number as DetailedType<0 | 1 | 2>],
   },
   union_mockUser_num: {
-    type: Object as SpecificType<Mock_User>,
+    type: Object as DetailedType<Mock_User>,
     optionalTypes: [Number],
   },
   union_num_mockUser: {
     type: Number,
-    optionalTypes: [Object as SpecificType<Mock_User>],
+    optionalTypes: [Object as DetailedType<Mock_User>],
   },
 } satisfies Record<string, RequiredUnion>;
 

package/src/api/RootComponent/Watch/test/WatchComputed.test.ts

@@ -1,6 +1,6 @@
 import { Checking, type Test } from "hry-types";
 import type { ReadonlyDeep } from "hry-types/src/Any/_api";
-import type { SpecificType } from "../../../../types/SpecificType";
+import type { DetailedType } from "../../../../types/DetailedType";
 import { RootComponent } from "../..";
 import type { Mock_User } from "../../Properties/test/normalRequired.test";
 
@@ -10,7 +10,7 @@ import type { Mock_User } from "../../Properties/test/normalRequired.test";
 RootComponent()({
   properties: {
     Pnum: Number,
-    obj: Object as SpecificType<Mock_User>,
+    obj: Object as DetailedType<Mock_User>,
   },
   data: {
     DNum: 123,

package/src/api/RootComponent/Watch/test/WatchProperties.test.ts

@@ -3,7 +3,7 @@ import { Checking, type Test } from "hry-types";
 import type { ReadonlyDeep } from "hry-types/src/Any/_api";
 import { RootComponent } from "../..";
 
-import type { SpecificType } from "../../../..";
+import type { DetailedType } from "../../../..";
 // import {
 //   type Mock_Cart,
 //   mock_requiredTypes,
@@ -23,11 +23,11 @@ const mock_optional = {
     value: 123,
   },
   optional_gender: {
-    type: String as SpecificType<"male" | "female">,
+    type: String as DetailedType<"male" | "female">,
     value: "male" as const,
   },
   optional_obj: {
-    type: Object as SpecificType<Mock_User>,
+    type: Object as DetailedType<Mock_User>,
     value: {
       id: "id",
       name: "name",
@@ -35,7 +35,7 @@ const mock_optional = {
     },
   },
   optional_objOrNull: {
-    type: Object as SpecificType<Mock_User | null>, // 可选类型定义null默认值方可为null
+    type: Object as DetailedType<Mock_User | null>, // 可选类型定义null默认值方可为null
     value: null,
   },
 } satisfies Record<string, OptionalType>;

package/src/api/RootComponent/index.ts

@@ -77,17 +77,10 @@ type RootComponentOptions<
 
 type RootComponentConstructor<TReceivedComponentDoc extends ComponentDoc[] | ComponentDoc> = {
   <
-    Literal extends
-      | string
-      | number
-      | boolean
-      | null
-      | Literal[]
-      | object,
     // TEvents 不能有默认值 {} 会引起事件参数类型(e)失效
     TEvents extends EventsConstraint<TReceivedComponentDoc>,
     TIsPage extends boolean = false,
-    TProperties extends PropertiesConstraint<Literal> = {},
+    const TProperties extends PropertiesConstraint = {},
     TData extends object = {},
     TStore extends StoreConstraint = {},
     TComputed extends ComputedConstraint = {},

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

@@ -19,11 +19,18 @@ type Root = {
   data: {
     str: string;
   };
+  store: {
+    SNum: number;
+  };
   computed: {
     bool: boolean;
   };
 };
 
+type $aaa = ComponentDoc<
+  { properties: { aaa_str: string; aaa_user: User | null; aaa_num: number; aaa_age: number } }
+>;
+
 SubComponent<{}, OnlyCustomCompDoc>()({
   // 1 CompDoc的properties为空时,可以写{}
   computed: {},
@@ -76,6 +83,7 @@ SubComponent<Root, OnlyPropsCompDoc>()({
         ReadonlyDeep<{
           num: number;
           user: User | null;
+          SNum: number;
           str: string;
           bool: boolean;
           aaa_num: number;
@@ -98,6 +106,7 @@ SubComponent<Root, OnlyPropsCompDoc>()({
           num: number;
           user: User | null;
           str: string;
+          SNum: number;
           bool: boolean;
           aaa_num: number;
           aaa_num123: 123;
@@ -110,18 +119,12 @@ SubComponent<Root, OnlyPropsCompDoc>()({
   },
 });
 
-// 计算属性可互相引用 ！！！但是没有自动提示！！！
-type CompDoc = ComponentDoc<
-  { properties: { aaa_num: number; aaa_user: User | null; aaa_xxx: number; aaa_age: number } }
->;
+// 计算属性可互相引用,但要加返回类型注释
 
-SubComponent<Root, CompDoc>()({
-  data: {
-    aaa_xxx: 123,
-  },
+SubComponent<Root, $aaa>()({
   computed: {
     aaa_num(): number {
-      return this.data.aaa_xxx;
+      return this.data.SNum;
     },
     aaa_user(): User | null {
       return this.data.user;
@@ -129,5 +132,8 @@ SubComponent<Root, CompDoc>()({
     aaa_age(): number {
       return this.data.aaa_num;
     },
+    aaa_str(): string {
+      return this.data.str;
+    },
   },
 });

package/src/api/SubComponent/index.ts

@@ -106,7 +106,8 @@ type SubComponentConstructor<
   AllRootDataDoc extends object =
     & Required<TRootDoc["properties"]>
     & TRootDoc["data"]
-    & TRootDoc["computed"],
+    & TRootDoc["computed"]
+    & TRootDoc["store"],
 > = {
   <
     TInherit extends InheritConstraint<AllRootDataDoc, CurrentCompDoc>,

package/src/index.ts

@@ -10,8 +10,17 @@ import { RootComponent } from "./api/RootComponent";
 
 import { SubComponent } from "./api/SubComponent";
 
-import type { SpecificType } from "./types/SpecificType";
+import type { DetailedType } from "./types/DetailedType";
 
+import type { GenerateDoc } from "./types/GenerateDoc";
 import type { ParamsEqual } from "./types/TwoParamsEqual";
 
-export { DefineComponent, navigateTo, type ParamsEqual, RootComponent, type SpecificType, SubComponent };
+export {
+  DefineComponent,
+  type DetailedType,
+  type GenerateDoc,
+  navigateTo,
+  type ParamsEqual,
+  RootComponent,
+  SubComponent,
+};

package/src/types/DetailedType.ts

@@ -0,0 +1,15 @@
+/**
+ * 通过as DetailedType 指定具体类型。
+ * @remarks
+ * 在js中使用构造函数(Object,Array等)表示类型时,无法给出明确的类型,DetailedType为此而生
+ * @example
+ * ``` ts
+ * RootComponent()({
+ *   properties: {
+ *     gender: String as DetailedType<"male" | "female">,
+ *     unionArr: Array as DetailedType<string[] | number[]>,
+ *   },
+ * });
+ * ```
+ */
+export type DetailedType<T = unknown> = { (): T } | { new(...arg: any[]): T };

package/src/types/GenerateDoc.ts

@@ -0,0 +1,19 @@
+import type { IfExtends } from "hry-types/src/Any/IfExtends";
+import type { ComputeIntersection } from "hry-types/src/Object/ComputeIntersection";
+import type { ComponentDoc } from "../api/DefineComponent/ReturnType/ComponentDoc";
+import type { AddPrefix } from "./AddPrefix";
+
+/**
+ * 生成组件文档类型
+ */
+export type GenerateDoc<TName extends string, T extends ComponentDoc> = ComputeIntersection<
+  & IfExtends<
+    unknown,
+    T["properties"],
+    {},
+    {
+      properties: AddPrefix<T["properties"] & {}, TName>;
+    }
+  >
+  & IfExtends<unknown, T["customEvents"], {}, { customEvents: AddPrefix<T["customEvents"] & {}, TName> }>
+>;