annil 1.0.0

package/src/api/DefineComponent/index.ts

@@ -0,0 +1,144 @@
+import type { IfExtends } from "hry-types/src/Any/IfExtends";
+import type { Func } from "hry-types/src/Misc/Func";
+import { BBeforeCreate } from "../../behaviors/BbeforeCreated";
+import { BComputedAndWatch } from "../../behaviors/BComputedAndWatch";
+import { initComputed } from "../../behaviors/BComputedAndWatch/initComputed";
+import { BStore } from "../../behaviors/BStore";
+import type { WMComponent, WMCompPageLifetimes, WMPageLifetimes } from "../../types/OfficialTypeAlias";
+import { isEmptyObject } from "../../utils/isEmptyObject";
+import {
+  excludeFields,
+  funcConfigHandle,
+  onLoadHijack,
+  onLoadReceivedDataHandle,
+  rootComponentFieldHandle,
+  subComponentsHandle,
+} from "../../utils/preprocessingOptions";
+import type { LifetimesConstraint } from "../RootComponent/Lifetimes/LifetimesConstraint";
+import type { RootComponentDoc } from "../RootComponent/RootComponentDoc";
+import type { SubComponentDoc } from "../SubComponent/SubComponentDoc";
+import type { NameOrPageOption as NameOrPathOption } from "./NameOrPage/NameOrPathOption";
+import type { CreateComponentDoc } from "./ReturnType/CreateComponentDoc";
+import type { CreatePageDoc } from "./ReturnType/CreatePageDoc";
+import type { RootComponentOption } from "./RootComponent/RootComponentOption";
+import type { SubComponentsOption } from "./SubComponents/SubComponentsOption";
+
+type RootOptions<
+  TRootComponentDoc extends RootComponentDoc,
+  TSubComponentTuple extends SubComponentDoc[],
+  TName extends string,
+  TPath extends Path,
+> =
+  & NameOrPathOption<TName, TPath, TRootComponentDoc>
+  & RootComponentOption<TRootComponentDoc>
+  & SubComponentsOption<TSubComponentTuple>;
+
+interface DefineComponentConstructor {
+  <
+    TRootComponentDoc extends RootComponentDoc = {},
+    TSubComponentTuple extends SubComponentDoc[] = [],
+    TName extends string = "",
+    TPath extends Path = "/",
+  >(
+    options: RootOptions<TRootComponentDoc, TSubComponentTuple, TName, TPath>,
+  ): // ReturnType 为  PageDoc or ComponentDoc
+  IfExtends<
+    "",
+    TName,
+    // 生成页面文档
+    CreatePageDoc<TRootComponentDoc, TPath, TSubComponentTuple>,
+    // 生成组件文档
+    CreateComponentDoc<TRootComponentDoc, TName, TSubComponentTuple>
+  >;
+}
+
+/**
+ * 临时的函数配置项
+ * 把根组件与子组件中配置类型为函数的相同字段配置收集在一起(数组)
+ */
+export type FuncConfig = {
+  pageLifetimes?: Record<string, Func[]>;
+  lifetimes?: Record<string, Func[]>;
+  watch?: Record<string, Func[]>;
+};
+
+/**
+ * 传入原生Component的配置项
+ */
+export type ComponentOptions = {
+  isPage?: boolean;
+  options?: WMComponent.Options;
+  properties?: object;
+  data?: object;
+  store?: object;
+  computed?: Record<string, Func>;
+  observers?: Record<string, Func>;
+  behaviors?: string[];
+  methods?: Record<string, Func> & { __storeConfig__?: Func };
+  watch?: Record<string, Func>;
+  lifetimes?: LifetimesConstraint;
+  pageLifetimes?: Partial<WMCompPageLifetimes & { load: Func } & WMPageLifetimes>;
+};
+
+export type Path = `/${string}`;
+
+export type DefineComponentOptions = {
+  path?: Path;
+  name?: string;
+  rootComponent?: RootComponentDoc;
+  subComponents?: SubComponentDoc[];
+};
+
+export const DefineComponent: DefineComponentConstructor = function(options): any {
+  // console.log("------------------------------------------------分割线------------------------------------------------");
+
+  // 最终的配置
+  const componentOptions: ComponentOptions = {
+    options: {
+      // addGlobalClass: true,
+      multipleSlots: true,
+      pureDataPattern: /^_/,
+      virtualHost: true,
+    },
+    // default behaviors
+    behaviors: [BStore, BComputedAndWatch],
+  };
+  /**
+   * 有些选项配置是函数,且可能分布在根组件和子组件中,tempConfig 用于收集这些配置,最终再一起整合进componentOptions配置。rootComponentHandle和subComponentsHandle都会收集配置，funcConfigHandle整理配置。
+   */
+  const funcConfig: FuncConfig = {};
+
+  if (options.rootComponent && !isEmptyObject(options.rootComponent)) {
+    rootComponentFieldHandle(options.rootComponent, componentOptions, funcConfig);
+  }
+
+  if (options.subComponents && !isEmptyObject(options.subComponents)) {
+    subComponentsHandle(componentOptions, options.subComponents, funcConfig);
+  }
+  if (!isEmptyObject(funcConfig)) {
+    funcConfigHandle(componentOptions, options.rootComponent?.isPage, funcConfig);
+  }
+
+  componentOptions.methods && excludeFields(componentOptions.methods, ["disposer", "applySetData"]);
+
+  componentOptions.behaviors!.push(BBeforeCreate);
+
+  onLoadHijack(componentOptions, [onLoadReceivedDataHandle, initComputed], []);
+
+  if (componentOptions.isPage) {
+    Reflect.deleteProperty(componentOptions.options!, "virtualHost");
+  }
+  Component(componentOptions as any);
+};
+
+export type PageOptions = {
+  path: Path;
+  rootComponent: RootComponentDoc & { isPage: true };
+  subComponents: SubComponentDoc[];
+};
+
+export type CompOptions = {
+  name: string;
+  rootComponent: RootComponentDoc & { isPage: undefined };
+  subComponents: SubComponentDoc[];
+};

package/src/api/InstanceInject/InstanceInject.ts

@@ -0,0 +1,25 @@
+// import type { WMComponentOption } from "../../types/officialAlias";
+
+// // export type InjectMethodConstraint = Record<string, Func>;
+
+// // export type InjectDataConstraint = Record<string, unknown>;
+
+// export abstract class Inject {
+//   public options?: WMComponentOption;
+//   // public methods?: InjectMethodConstraint;
+//   // public data?: InjectDataConstraint;
+// }
+
+// /**
+//  * 实例注入接口,加入数据到所有实例中(当前仅支持data,methods,options字段),可在this上获取对应数据 响应式需函数返回方式
+//  * @example
+//  */
+// export class InstanceInject extends Inject {
+//   private static _injectOption = new InstanceInject();
+//   public static get InjectOption(): InstanceInject {
+//     return this._injectOption;
+//   }
+//   public static set InjectOption(options: InstanceInject) {
+//     this._injectOption = options;
+//   }
+// }

package/src/api/InstanceInject/test/InjectConfig.ts

@@ -0,0 +1,50 @@
+// import { InstanceInject } from "../../..";
+
+// import { observable } from "mobx";
+// import type { InjectDataConstraint, InjectMethodConstraint } from "../InstanceInject";
+
+// const reactiveUser = observable({
+//   name: "zhao",
+//   age: 18,
+// });
+
+// /**
+//  *  @description 注入的data
+//  */
+// const data = {
+//   // 响应式数据
+//   reactiveUser: () => reactiveUser,
+//   // 非响应式数据
+//   injectStr: "injectStr",
+// } satisfies InjectDataConstraint;
+// /**
+//  * @description 注入的方法
+//  */
+// const methods = {
+//   injectMethod(data: string) {
+//     console.log(data);
+//   },
+// } satisfies InjectMethodConstraint;
+/**
+ * 注入的配置
+ */
+// const options = {
+//   addGlobalClass: true,
+//   multipleSlots: true,
+//   pureDataPattern: /^_/,
+//   virtualHost: true,
+// };
+
+// InstanceInject.InjectOption = {
+//   // data,
+//   options,
+//   // methods,
+// };
+
+// 声明注入类型
+// declare module "../../.." {
+//   interface InstanceInject {
+//     data: typeof data;
+//     methods: typeof methods;
+//   }
+// }

package/src/api/RootComponent/Computed/ComputedConstraint.ts

@@ -0,0 +1,4 @@
+/**
+ * RootComponent API Computed 字段约束
+ */
+export type ComputedConstraint = Record<string, () => any>;

package/src/api/RootComponent/Computed/ComputedOption.ts

@@ -0,0 +1,12 @@
+import type { DuplicateFieldValidator } from "hry-types/src/Generic/DuplicateFieldValidator";
+
+import type { ComputedConstraint } from "./ComputedConstraint";
+
+export type ComputedOption<TComputed extends ComputedConstraint, OtherData extends object> = {
+  /**
+   * 计算属性字段,可通过this.data获取其他数据
+   */
+  computed?:
+    & TComputed
+    & DuplicateFieldValidator<TComputed, keyof OtherData>;
+};

package/src/api/RootComponent/Computed/GetComputedDoc.ts

@@ -0,0 +1,10 @@
+import type { ComputedConstraint } from "./ComputedConstraint";
+
+/**
+ * 获取computed字段文档类型
+ * @param T - ComputedConstraint
+ * @returns object
+ */
+export type GetComputedDoc<TComputed extends ComputedConstraint> = TComputed extends unknown
+  ? { [k in keyof TComputed]: ReturnType<TComputed[k]> }
+  : never;

package/src/api/RootComponent/Computed/test/GetComputedDoc.test.ts

@@ -0,0 +1,24 @@
+import { Checking, type Test } from "hry-types";
+import type { GetComputedDoc } from "../GetComputedDoc";
+
+// test1 非空对象字段
+
+type Test1 = GetComputedDoc<{
+  a: () => number;
+  b: () => string;
+  c: () => "male" | "femal";
+}>;
+
+type Test1Expected = {
+  a: number;
+  b: string;
+  c: "male" | "femal";
+};
+
+Checking<Test1, Test1Expected, Test.Pass>;
+
+// test2 空对象字段 返回空
+
+type Test2 = GetComputedDoc<{}>;
+
+Checking<Test2, {}, Test.Pass>;

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

@@ -0,0 +1,37 @@
+import { RootComponent } from "../..";
+
+// 1 重复字段
+RootComponent()({
+  properties: {
+    str: String,
+  },
+  data: {
+    num: 123,
+  },
+  computed: {
+    // @ts-expect-error '与properties字段重复'
+    str() {
+      return "与properties字段重复";
+    },
+    // @ts-expect-error "与data字段重复"
+    num() {
+      return "与data字段重复";
+    },
+  },
+});
+
+// 2 循环引用
+RootComponent()({
+  computed: {
+    // @ts-expect-error  相互引用
+    str() {
+      // @ts-ignore 相互引用
+      return this.data.num;
+    },
+    // @ts-expect-error 相互引用
+    num() {
+      // @ts-expect-error 相互引用
+      return this.data.str;
+    },
+  },
+});

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

@@ -0,0 +1,99 @@
+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 "../../Properties/expected/normalRequired";
+
+/**
+ * computed字段约束为 [ComputedConstraint](../ComputedConstraint.ts)
+ */
+const RootDoc = RootComponent()({
+  properties: {
+    firstName: String,
+  },
+  data: {
+    lastName: "lastName",
+  },
+  computed: {
+    fullName() {
+      // 1 计算属性字段可以通过this.data 引用properties、data
+      return this.data.firstName + this.data.lastName;
+    },
+    user() {
+      return {} as Mock_User;
+    },
+    // 2. 可依赖其他计算字段
+    id_fullName() {
+      return this.data.user.id + this.data.fullName;
+    },
+    readOnly() {
+      // 3 this.data 类型是深度只读的
+      Checking<
+        typeof this.data,
+        ReadonlyDeep<{
+          firstName: string;
+          lastName: string;
+          fullName: string;
+          user: Mock_User;
+          id_fullName: string;
+          readOnly: "str";
+        }>,
+        Test.Pass
+      >;
+
+      return "str";
+    },
+  },
+});
+
+// 4. 返回的文档类型中computed类型为计算字段函数返回类型
+type ComputedDocExpected = {
+  fullName: string;
+  user: Mock_User;
+  id_fullName: string;
+  readOnly: "str";
+};
+
+Checking<typeof RootDoc["computed"], ComputedDocExpected, Test.Pass>;
+
+/**
+ *  5 无计算属性字段时,返回文档中无computed字段
+ */
+const noComputedFieldDoc = RootComponent()({
+  methods: {
+    M1() {
+      // 5.1 无computed,this.data中为{}
+      Checking<typeof this.data, {}, Test.Pass>;
+    },
+  },
+});
+
+Checking<typeof noComputedFieldDoc, { methods: { M1: () => void } }, Test.Pass>;
+
+/**
+ *  6 计算属性字段为空对象时,返回文档中无computed字段
+ */
+const EmptyComputedFieldDoc = RootComponent()({
+  computed: {},
+  methods: {
+    M1() {
+      // 6.1 computed为{},this.data中为{}
+      Checking<typeof this.data, {}, Test.Pass>;
+    },
+  },
+});
+
+Checking<typeof EmptyComputedFieldDoc, { methods: { M1: () => void } }, Test.Pass>;
+
+RootComponent()({
+  isPage: true,
+  properties: {
+    obj: Object as SpecificType<{ name: string; age: number }>,
+  },
+  computed: {
+    age() {
+      // 页面实例对象不添加Null,因为计算属性初始化在onLoad之后(即properties已传入时,且不会传入Null)
+      return this.data.obj.age;
+    },
+  },
+});

package/src/api/RootComponent/CustomEvents/CustomEventConstraint.ts

@@ -0,0 +1,50 @@
+import type { SpecificType } from "../../../types/SpecificType";
+
+type SimpleCustomeEvents = SpecificType | null;
+
+export type SimpleCustomeEventsList = SimpleCustomeEvents[];
+
+export type ShortCustomeEvents = SimpleCustomeEvents | SimpleCustomeEventsList;
+
+// options
+type BubblesConfig = { bubbles: true };
+
+type CaptureConfig = { capturePhase: true };
+
+type ComposedCongifg = { composed: true };
+
+type NonBubblesConfig = { bubbles?: never };
+
+type NonComposedConfig = { composed?: never };
+
+type NonCaptureConfig = { capturePhase?: never };
+
+export type BubblesOption = BubblesConfig & NonComposedConfig & NonCaptureConfig;
+
+export type CaptureOption = CaptureConfig & NonBubblesConfig & NonComposedConfig;
+
+export type BubblesCaptureOption = BubblesConfig & CaptureConfig & NonComposedConfig;
+
+export type BubblesComposedOption = BubblesConfig & ComposedCongifg & NonCaptureConfig;
+
+export type CaptureComposedOption = CaptureConfig & ComposedCongifg & NonBubblesConfig;
+
+export type BubblesCaptureComposedOption = BubblesConfig & ComposedCongifg & CaptureConfig;
+
+export type OptionsFieldsConfigOfCustomEvents =
+  | BubblesOption
+  | CaptureOption
+  | BubblesCaptureOption
+  | BubblesComposedOption
+  | CaptureComposedOption
+  | BubblesCaptureComposedOption;
+
+/**
+ * 带options的CustomEvents配置
+ */
+export type FullCustomEvents = {
+  detailType: ShortCustomeEvents;
+  options: OptionsFieldsConfigOfCustomEvents;
+};
+
+export type CustomEventConstraint = Record<string, FullCustomEvents | ShortCustomeEvents>;

package/src/api/RootComponent/CustomEvents/CustomEventsDoc.ts

@@ -0,0 +1,4 @@
+import type { Primitive } from "hry-types/src/_internal/Primitive";
+import type { CustomEventsTags } from "./CustomEventsTag";
+
+export type CustomEventsDoc = { [k in string]: Exclude<Primitive, undefined> | object | CustomEventsTags };

package/src/api/RootComponent/CustomEvents/CustomEventsOption.ts

@@ -0,0 +1,37 @@
+import type { V } from "hry-types";
+import type { CustomEventConstraint } from "./CustomEventConstraint";
+
+/**
+ * customEvents字段泛型输入
+ */
+export type CustomEventsOption<
+  TCustomEvents extends CustomEventConstraint,
+  DuplicateFieldCheck,
+> = {
+  /**
+   * 自定义事件
+   * @remarks 使用this.customEventsA 调用
+   * @example
+   * ```ts
+   *  {
+   *   // ...
+   *   customEvents: {
+   *     A: Number, // number
+   *     B: [String as SpecificType<"male" | "femal">, Number], // "male" | "femal" | number
+   *     C: {
+   *       detailType: String,
+   *       options: {
+   *         bubbles: true,
+   *         composed: true,
+   *         capturePhase: true,
+   *       },
+   *     },
+   *   },
+   * };
+   * ```
+   */
+  customEvents?:
+    & TCustomEvents
+    & V.IllegalFieldValidator<TCustomEvents, "bubbles" | "composed" | "capturePhase", 1, "options">
+    & V.DuplicateFieldValidator<TCustomEvents, keyof DuplicateFieldCheck, "与events字段重复">;
+};

package/src/api/RootComponent/CustomEvents/CustomEventsTag.ts

@@ -0,0 +1,59 @@
+import type { IfExtends } from "hry-types/src/Any/IfExtends";
+import type {
+  BubblesCaptureComposedOption,
+  BubblesCaptureOption,
+  BubblesComposedOption,
+  BubblesOption,
+  CaptureComposedOption,
+  CaptureOption,
+  OptionsFieldsConfigOfCustomEvents,
+} from "./CustomEventConstraint";
+
+export type Bubbles = () => "bubbles";
+
+export type Capture = () => "capture";
+
+export type Composed = () => "Composed";
+
+export type BubblesCapture = Bubbles | Capture;
+
+export type BubblesComposed = Bubbles | Composed;
+
+export type CaptureComposed = Capture | Composed;
+
+export type BubblesCaptureComposed = Bubbles | Capture | Composed;
+
+export type CustomEventsTags =
+  | Bubbles
+  | Capture
+  | BubblesCapture
+  | BubblesComposed
+  | CaptureComposed
+  | BubblesCaptureComposed;
+
+export type AddTagForCustomEventsDoc<Options extends OptionsFieldsConfigOfCustomEvents> = IfExtends<
+  BubblesOption,
+  Options,
+  Bubbles,
+  IfExtends<
+    CaptureOption,
+    Options,
+    Capture,
+    IfExtends<
+      BubblesCaptureOption,
+      Options,
+      BubblesCapture,
+      IfExtends<
+        BubblesComposedOption,
+        Options,
+        BubblesComposed,
+        IfExtends<
+          CaptureComposedOption,
+          Options,
+          CaptureComposed,
+          IfExtends<BubblesCaptureComposedOption, Options, BubblesCaptureComposed>
+        >
+      >
+    >
+  >
+>;

package/src/api/RootComponent/CustomEvents/GetCustomEventDoc.ts

@@ -0,0 +1,46 @@
+import type { InferSpecificType } from "../../../types/InferSpecificType";
+import type { SpecificType } from "../../../types/SpecificType";
+import type {
+  CustomEventConstraint,
+  FullCustomEvents,
+  ShortCustomeEvents,
+  SimpleCustomeEventsList,
+} from "./CustomEventConstraint";
+import type { AddTagForCustomEventsDoc } from "./CustomEventsTag";
+
+export type GetShortCustomEventsDoc<T extends ShortCustomeEvents> = T extends SpecificType ? InferSpecificType<T>
+  : T extends null ? null
+  : T extends SimpleCustomeEventsList ? GetShortCustomEventsDoc<T[number]>
+  : never;
+
+export type GetFullCustomEventsDoc<T extends FullCustomEvents> =
+  | GetShortCustomEventsDoc<T["detailType"]>
+  | AddTagForCustomEventsDoc<T["options"]>;
+
+/**
+ * 获取自定义事件的文档
+ * demo
+ * ```ts
+ * customEvents:{
+ *   a:Number,
+ *   b:{ detailType: String,options:{ bubbles:true } }
+ *   c:{ detailType: Number,options:{ bubbles:true, composed:true } }
+ * }
+ * //result => {a:number,b:string|()=>'bubbles',c:number | ()=>'composed' }
+ * ```
+ * @returns object
+ */
+// @dprint-ignore
+export type GetCustomEventDoc<T extends CustomEventConstraint> = 
+  {
+    [k in keyof T]: T[k] extends ShortCustomeEvents ? GetShortCustomEventsDoc<T[k]>  
+    // 应该写GetFullCustomEventsDoc<T[k]>带鼠标悬停时不是计算结果。所以代码重复了。
+      : // @ts-ignore T[k] 一定为 FullCustomEvents 类型
+        | GetShortCustomEventsDoc<T[k]["detailType"]>
+        // 为自定义事件模型加标记,方便识别
+        // @ts-ignore T[k] 一定为 FullCustomEvents 类型
+        | AddTagForCustomEventsDoc<T[k]["options"]>;
+  }
+;
+
+// type ddd = IsUnion

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

@@ -0,0 +1,30 @@
+import { Checking, type Test } from "hry-types";
+import type { GetCustomEventDoc } from "../GetCustomEventDoc";
+
+import {
+  type BubblesCapturePhaseComposedExpected,
+  type BubblesCapturePhaseExpected,
+  type BubblesComposedExpected,
+  type bubblesExpected,
+  type CapturePhaseComposedExpected,
+  type CapturePhaseExpected,
+} from "./GetFullEventDoc.test";
+import { type ListExpected, type NullExpected, type StrExpected, type UnionStrExpected } from "./GetShortEventDoc.test";
+import { mock_customEvents } from "./normal.test";
+
+type Mock_CustomEventsDoc = GetCustomEventDoc<typeof mock_customEvents>;
+
+export type Mock_CustomEventsDocExpected = {
+  str: StrExpected;
+  null: NullExpected;
+  unionStr: UnionStrExpected;
+  union: ListExpected;
+  bubbles: bubblesExpected;
+  capturePhase: CapturePhaseExpected;
+  bubbles_capturePhase: BubblesCapturePhaseExpected;
+  bubbles_composed: BubblesComposedExpected;
+  capturePhase_composed: CapturePhaseComposedExpected;
+  bubbles_capturePhase_composed: BubblesCapturePhaseComposedExpected;
+};
+
+Checking<Mock_CustomEventsDoc, Mock_CustomEventsDocExpected, Test.Pass>;