annil 1.0.0

package/src/types/InferSpecificType.test.ts

@@ -0,0 +1,18 @@
+import { Checking, type Test } from "hry-types";
+
+import type { InferSpecificType } from "./InferSpecificType";
+import type { SpecificType } from "./SpecificType";
+
+Checking<InferSpecificType<StringConstructor>, string, Test.Pass>;
+
+Checking<InferSpecificType<NumberConstructor>, number, Test.Pass>;
+
+Checking<InferSpecificType<BooleanConstructor>, boolean, Test.Pass>;
+
+Checking<InferSpecificType<ArrayConstructor>, unknown[], Test.Pass>;
+
+Checking<InferSpecificType<ObjectConstructor>, object, Test.Pass>;
+
+Checking<InferSpecificType<SpecificType<"a" | "b">>, "a" | "b", Test.Pass>;
+
+Checking<InferSpecificType<SpecificType<[string, number, boolean]>>, [string, number, boolean], Test.Pass>;

package/src/types/InferSpecificType.ts

@@ -0,0 +1,12 @@
+import type { SpecificType } from "./SpecificType";
+
+/**
+ * 解析SpecificType的真实类型
+ */
+export type InferSpecificType<T> = T extends StringConstructor ? string
+  : T extends NumberConstructor ? number
+  : T extends BooleanConstructor ? boolean
+  : T extends ArrayConstructor ? unknown[]
+  : T extends ObjectConstructor ? object
+  : T extends SpecificType<infer R> ? R
+  : never;

package/src/types/ListOfSamePrimitive.ts

@@ -0,0 +1,20 @@
+/**
+ * 提取联合类型中相同原始类型为数组的一项
+ * @example
+ * ```ts
+ * type test = ListOfSamePrimitive< 1 | 2 | "a" | "b" | { name: string } | { age: number } | string[] | number[]>
+ * //=> ["a" | "b", 1 | 2, string[] | number[], {name: string;} | {age: number;}]
+ * ```
+ */
+
+import type { RemoveNever } from "./RemoveNever";
+
+export type ListOfSamePrimitive<U> = RemoveNever<
+  [
+    Extract<U, string>,
+    Extract<U, number>,
+    Extract<U, boolean>,
+    Extract<U, unknown[]>,
+    U extends unknown[] ? never : Extract<U, object>,
+  ]
+>;

package/src/types/OfficialTypeAlias.ts

@@ -0,0 +1,111 @@
+export type WMTriggerEventOption = WechatMiniprogram.Component.TriggerEventOption;
+
+export type WMCustomEvent<
+  Detail = object,
+  Mark extends object = object,
+  CurrentTargetDataset extends object = object,
+  TargetDataset extends object = CurrentTargetDataset,
+> = WechatMiniprogram.CustomEvent<
+  // @ts-ignore
+  Detail,
+  Mark,
+  CurrentTargetDataset,
+  TargetDataset
+>;
+
+export type WMBaseEvent<
+  Mark extends object = object,
+  CurrentTargetDataset extends object = object,
+  TargetDataset extends object = CurrentTargetDataset,
+> = WechatMiniprogram.BaseEvent<Mark, CurrentTargetDataset, TargetDataset>;
+
+/**
+ * 事件触发组件的Dataset类型
+ */
+export type Dataset<
+  TCurrentTargetDataset extends object,
+  TargetDataset extends object = TCurrentTargetDataset,
+  Detail = {},
+> = WMCustomEvent<Detail, object, TCurrentTargetDataset, TargetDataset>;
+
+/**
+ * 自定义事件Detail类型
+ */
+export type Mark<TMark extends object> = WechatMiniprogram.CustomEvent<
+  {},
+  TMark,
+  {},
+  {}
+>;
+
+/**
+ * 自定义事件Detail类型
+ */
+export type Detail<T> = WMCustomEvent<T>;
+
+/**
+ * 当前事件组件Dataset
+ */
+export type CurrentTargetDataset<T extends object> = WMCustomEvent<{}, {}, T>;
+
+/**
+ * 触发事件组件Dataset
+ */
+export type TargetDataset<TargetDataset extends object> = WMCustomEvent<{}, {}, {}, TargetDataset>;
+
+// export type WMTrivialOption<
+//   TData extends WechatMiniprogram.Component.DataOption,
+//   TProperty extends WechatMiniprogram.Component.PropertyOption,
+//   TMethod extends WechatMiniprogram.Component.MethodOption,
+//   TCustomInstanceProperty extends WechatMiniprogram.IAnyObject = {},
+//   TIsPage extends boolean = false,
+export type WMComponentOption = WechatMiniprogram.Component.TrivialOption;
+
+export type WMNavigateToSuccessCallbackResult = WechatMiniprogram.NavigateToSuccessCallbackResult;
+
+export type WMCompPageLifetimes = WechatMiniprogram.Component.PageLifetimes;
+
+export type WMComponentInstance = WechatMiniprogram.Component.InstanceProperties;
+
+export type WMPageInstance = WechatMiniprogram.Page.InstanceProperties;
+
+export type WMNavigateToOption = WechatMiniprogram.NavigateToOption;
+
+export type WMInstanceMethods<T extends object> = WechatMiniprogram.Component.InstanceMethods<T>;
+
+export type WMCompLifetimes = WechatMiniprogram.Component.Lifetimes;
+
+export type WMCompOtherOption = WechatMiniprogram.Component.OtherOption;
+
+export type WMPageLifetimes = WechatMiniprogram.Page.ILifetime;
+
+export declare namespace WMComponent {
+  interface Options {
+    /**
+     * [启用多slot支持](https://developers.weixin.qq.com/miniprogram/dev/framework/custom-component/wxml-wxss.html#组件wxml的slot)
+     */
+    multipleSlots?: boolean;
+    /**
+     * 原始文档 [组件样式隔离](https://developers.weixin.qq.com/miniprogram/dev/framework/custom-component/wxml-wxss.html#组件样式隔离)
+     * @deprecated glass-easel框架下被废弃  [兼容文档](https://developers.weixin.qq.com/miniprogram/dev/framework/custom-component/glass-easel/migration.html#JSON-%E9%85%8D%E7%BD%AE)
+     */
+    addGlobalClass?: boolean;
+    /**
+     * [组件样式隔离](https://developers.weixin.qq.com/miniprogram/dev/framework/custom-component/wxml-wxss.html#组件样式隔离)
+     */
+    styleIsolation?:
+      | "isolated"
+      | "apply-shared"
+      | "shared"
+      | "page-isolated"
+      | "page-apply-shared"
+      | "page-shared";
+    /**
+     * [纯数据字段](https://developers.weixin.qq.com/miniprogram/dev/framework/custom-component/pure-data.html) 是一些不用于界面渲染的 data 字段，可以用于提升页面更新性能。从小程序基础库版本 2.8.2 开始支持。
+     */
+    pureDataPattern?: RegExp;
+    /**
+     * [虚拟化组件节点](https://developers.weixin.qq.com/miniprogram/dev/framework/custom-component/wxml-wxss.html#%E8%99%9A%E6%8B%9F%E5%8C%96%E7%BB%84%E4%BB%B6%E8%8A%82%E7%82%B9) 使自定义组件内部的第一层节点由自定义组件本身完全决定。从小程序基础库版本 [`2.11.2`](https://developers.weixin.qq.com/miniprogram/dev/framework/compatibility.html) 开始支持 */
+    virtualHost?: boolean;
+  }
+}

package/src/types/PrefixValidator.ts

@@ -0,0 +1,56 @@
+import type { Func } from "hry-types/src/Misc/Func";
+
+/**
+ * 验证泛型对象的前缀是否正确
+ * @example
+ * ```ts
+ * // 前缀字段为 '' 时 验证结果为unknown
+ * function test<T extends object>(O: T & PrefixValidator<T, "">): T {
+ *  return O;
+ * }
+ *
+ * test({
+ * num: 123, // ok
+ * str: "str", // ok
+ * });
+ *
+ * // 前缀字段非空串时 泛型对象字段不满足前缀 aaa 报错
+ * function test1<T extends object>(O: T & PrefixValidator<T, "aaa">): T {
+ * return O;
+ * }
+ *
+ * test1({
+ * aaa: 123,
+ * aaaa: "str",
+ * aaa_num: 123,
+ * aaaStr: "str",
+ * // @ts-expect-error 前缀错误
+ * str: "str",
+ * // @ts-expect-error 前缀错误
+ * _str: "str",
+ * });
+ *
+ * // 前缀字段非空传时 泛型对象字段不满足前缀 aaa | _aaa报错
+ * function test2<T extends object>(O: T & PrefixValidator<T, "num" | "_num">): T {
+ * return O;
+ * }
+ *
+ * test2({
+ * num: 123,
+ * _num: "str",
+ * });
+ * ```
+ * @param G - 泛型对象 object
+ * @param TPrefix - 前缀 string
+ * @param Error - 错误提示 string
+ * @returns unknown or object
+ */
+export type PrefixValidator<
+  G extends object,
+  TPrefix extends string,
+  Error extends string = "前缀错误",
+> = "" extends TPrefix ? unknown : {
+  [
+    k in keyof G as k extends `${TPrefix}_${string}` ? never : k
+  ]: G[k] extends Func ? `⚠️${Error}` : () => `⚠️${Error}`;
+};

package/src/types/RemoveNever.ts

@@ -0,0 +1,6 @@
+export type RemoveNever<T extends unknown[]> = T extends [
+  infer A,
+  ...infer B,
+] ? [A] extends [never] ? RemoveNever<B>
+  : [A, ...RemoveNever<B>]
+  : T;

package/src/types/RemoveNullOfRequired.ts

@@ -0,0 +1,8 @@
+import type { RequiredKeys } from "hry-types/src/Object/RequiredKeys";
+
+/**
+ * 去除对象中非可选字段类型中的null
+ */
+export type RemoveNullOfRequired<T extends object, RequireKeys extends keyof T = RequiredKeys<T>> = {
+  [k in keyof T]: k extends RequireKeys ? Exclude<T[k], null> : T[k];
+};

package/src/types/RemovePrefix.ts

@@ -0,0 +1,3 @@
+export type RemovePrefix<T extends object, Tag extends string = "_"> = {
+  [k in keyof T as k extends `${string}${Tag}${infer Key}` ? Key : k]: T[k];
+};

package/src/types/ReplacePrefix.ts

@@ -0,0 +1,47 @@
+import { Checking, type Test } from "hry-types";
+import type { IfExtends } from "hry-types/src/Any/IfExtends";
+import type { ComponentDoc } from "../api/DefineComponent/ReturnType/ComponentDoc";
+// import type { ComponentDoc } from "../api/DefineComponent/CreateDoc/ComponentDoc";
+
+type _ReplacePrefix<O, TPrefix extends string> = {
+  [k in keyof O as k extends `${string}_${infer L}` ? `${TPrefix}_${L}` : k]: O[k];
+};
+
+/**
+ * 更改文档前缀
+ * @param TComponentDoc - ComponentDoc
+ * @returns ComponentDoc
+ */
+export type ReplacePrefix<TComponentDoc extends ComponentDoc, TPrefix extends string = ""> =
+  & IfExtends<
+    unknown,
+    TComponentDoc["properties"],
+    {},
+    {
+      properties: _ReplacePrefix<TComponentDoc["properties"], TPrefix>;
+    }
+  >
+  & IfExtends<
+    unknown,
+    TComponentDoc["customEvents"],
+    {},
+    { customEvents: _ReplacePrefix<TComponentDoc["customEvents"], TPrefix> }
+  >;
+
+type Test1 = ReplacePrefix<{ properties: { xxx_name: string } }, "xxxDaa">;
+
+type Test1Expect = { properties: { xxxDaa_name: string } };
+
+Checking<Test1, Test1Expect, Test.Pass>;
+
+type Test2 = ReplacePrefix<{ customEvents: { xxx_name: string } }, "xxxDaa">;
+
+type Test2Expect = { customEvents: { xxxDaa_name: string } };
+
+Checking<Test2, Test2Expect, Test.Pass>;
+
+type Test3 = ReplacePrefix<{}, "xxxDaa">;
+
+type Test3Expect = {};
+
+Checking<Test3, Test3Expect, Test.Pass>;

package/src/types/RequiredKeys.ts

@@ -0,0 +1,8 @@
+/**
+ * 获取对象(联合对象)的必选属性
+ * @remarks 利用 `{} extends { x?:string }` 为true的特性
+ */
+export type RequiredKeys<O extends object> = O extends unknown ? {
+    [K in keyof O]-?: {} extends Pick<O, K> ? never : K;
+  }[keyof O]
+  : never;

package/src/types/RestorePropTypeOfList.ts

@@ -0,0 +1,20 @@
+import { Checking, type Test } from "hry-types";
+import type { SpecificType } from "./SpecificType";
+
+export type ReStorePropTypeOfList<L, R extends unknown[] = []> = L extends [infer Head, ...infer Rest]
+  ? ReStorePropTypeOfList<Rest, [...R, SpecificType<Head>]>
+  : R;
+
+type Test1 = ReStorePropTypeOfList<[number, string, { c: boolean }, boolean, string[]]>;
+
+type Test1Expect = [
+  SpecificType<number>,
+  SpecificType<string>,
+  SpecificType<{
+    c: boolean;
+  }>,
+  SpecificType<boolean>,
+  SpecificType<string[]>,
+];
+
+Checking<Test1, Test1Expect, Test.Pass>;

package/src/types/RestorePropertiesDoc.ts

@@ -0,0 +1,26 @@
+// import type { ComponentDoc } from "../api/DefineComponent/CreateDoc/ComponentDoc";
+// import type { Drop } from "./Drop";
+
+// import type { ListOfSamePrimitive } from "./ListOfSamePrimitive";
+// import type { ReStorePropTypeOfList } from "./ReStorePropTypeOfList";
+// import type { SpecificType } from "./SpecificType";
+
+/**
+ * 还原properties描述
+ * @example
+ * ```ts
+ * type doc = {properties:{a:'1'|'2',b:boolean,c:string[],d:{name:string}}}
+ * type test = ReStorePropertiesDoc<doc>
+ * //=> {a: "1" | "2" | {type: "1" | "2"; value?: "1" | "2";}; b: boolean | {type: boolean; value?: boolean;}; c: string[] | {type: string[]; value?: string[];}; d: {name: string;} | {type: {name: string;}; value?: {name: string;};}}
+ * ```
+ */
+// type ReStorePropertiesDoc<T extends ComponentDoc> = {
+//   [k in keyof T]?: ListOfSamePrimitive<T[k]> extends infer R extends unknown[]
+//     ? R["length"] extends 1 ? SpecificType<R[0]> | { type: SpecificType<R[0]>; value: R[0] }
+//     : {
+//       type: SpecificType<R[0]>;
+//       value?: R[0];
+//       optionalTypes?: ReStorePropTypeOfList<Drop<R, R[0]>>[number][];
+//     }
+//     : never;
+// };

package/src/types/Shift.ts

@@ -0,0 +1,2 @@
+export type Shift<L extends readonly unknown[]> = L extends [unknown, ...infer Rest] ? Rest
+  : [];

package/src/types/SpecificType.ts

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

package/src/types/TwoParamsEqual.ts

@@ -0,0 +1,3 @@
+import type { Equals } from "hry-types/src/Any/_api";
+
+export type ParamsEqual<A, B extends Equals<A, B> extends true ? unknown : never> = true;

package/src/types/UnionToComma.test.ts

@@ -0,0 +1,9 @@
+import type { IsUnion } from "hry-types/src/Any/IsUnion";
+import type { Last } from "hry-types/src/Union/Last";
+
+type _UnionToComma<U, Prev extends string> = [U] extends [never] ? Prev
+  : _UnionToComma<Exclude<U, Last<U>>, `${Last<U> & string}、${Prev}`>;
+
+export type UnionToComma<U extends string> = IsUnion<U> extends true
+  ? _UnionToComma<Exclude<U, Last<U>>, Last<U> & string>
+  : U;

package/src/types/Validators.ts

@@ -0,0 +1,17 @@
+// import { Checking, type Test } from "hry-types";
+
+export type Validators<L extends unknown[]> = L extends [infer Head, ...infer Tail extends unknown[]]
+  ? unknown extends Head ? Validators<Tail> : Head
+  : unknown;
+
+// type list = [1, 2, 3];
+
+// type list2 = [unknown, 1, 2];
+
+// type lll = Validators<list>;
+
+// Checking<lll, 1, Test.Pass>;
+
+// type lll2 = Validators<list2>;
+
+// Checking<lll2, 1, Test.Pass>;

package/src/utils/InnerMarker.ts

@@ -0,0 +1,4 @@
+export const INNERMARKER = {
+  url: "__missannil__" satisfies `_${string}`, // url默认传值Data字段 必须是内部字段,因为会加入到实例的data下。
+  // defUrl: "/xx&xx", // 标记 组件默认的的url类型
+};

package/src/utils/computedUpdater.ts

@@ -0,0 +1,51 @@
+import { deepProxy, unwrap } from "../behaviors/BComputedAndWatch/data-tracer";
+import type { ComputedDependence } from "../behaviors/BComputedAndWatch/initComputed";
+import { isEqual } from "../behaviors/BComputedAndWatch/isEqual";
+import type { Instance } from "../behaviors/BComputedAndWatch/types";
+import { getPathsValue } from "./getPathsValue";
+
+export function computedUpdater(this: Instance, isUpdated = false): boolean {
+  // console.log("computedUpdater开始");
+
+  // console.log("循环判断缓存中每个计算属性依赖是否有变化");
+
+  for (const key in this.__computedCache__) {
+    // console.log("当前计算属性为:", key);
+
+    const itemCache = this.__computedCache__[key];
+    let changed = false;
+    for (const dep of itemCache.dependences) {
+      const curVal = getPathsValue.call(this, dep.paths);
+
+      // 检查依赖是否更新
+      if (!isEqual(curVal, dep.val)) {
+        changed = true;
+
+        break;
+      }
+    }
+
+    if (changed) {
+      const newDependences: ComputedDependence[] = [];
+
+      const newValue = itemCache.method.call({
+        data: deepProxy(this.data, newDependences),
+      });
+
+      // 更新值不会立即再次进入**函数,而是当前**函数运行完毕后触发**函数,
+      this.setData({
+        [key]: unwrap(newValue),
+      });
+
+      isUpdated = true;
+
+      // 更新依赖
+      this.__computedCache__[key].dependences = newDependences;
+
+      // 有一个计算属性更新就重新更新所有计算互相,避免后置依赖导致前置依赖错误
+      return computedUpdater.call(this, isUpdated);
+    }
+  }
+
+  return isUpdated;
+}

package/src/utils/deepClone.ts

@@ -0,0 +1,19 @@
+/**
+ * 深度克隆 函数相同 原型一致
+ */
+export function deepClone<T>(value: T): T {
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  const clone = (Array.isArray(value) ? [] : {}) as T;
+
+  Object.setPrototypeOf(clone, Object.getPrototypeOf(value));
+
+  for (const key in value) {
+    if (Object.prototype.hasOwnProperty.call(value, key)) {
+      clone[key] = deepClone(value[key]);
+    }
+  }
+
+  return clone;
+}

package/src/utils/deleteProtoField.ts

@@ -0,0 +1,6 @@
+/**
+ * 删除对象原型上的属性(只是上级原型)
+ */
+export function deleteProtoField<T extends object>(obj: T, key: keyof T) {
+  Reflect.deleteProperty(Object.getPrototypeOf(obj), key);
+}

package/src/utils/getPathsValue.ts

@@ -0,0 +1,12 @@
+import type { Instance } from "../behaviors/BComputedAndWatch/types";
+
+export function getPathsValue(this: Instance, paths: string[]) {
+  return paths.reduce((pre: any, path) => {
+    // pre有可能为undefined|null,比如paths(['computedUser','name'])的首路径为还未初始化的计算属性(undefined),还有可能是properties的对象类型(默认为null)
+    try {
+      return pre[path];
+    } catch (error) {
+      return undefined;
+    }
+  }, this.data);
+}

package/src/utils/initWatchOldValue.ts

@@ -0,0 +1,12 @@
+import type { Instance, WatchOldValue } from "../behaviors/BComputedAndWatch/types";
+import { deepClone } from "./deepClone";
+import { getPathsValue } from "./getPathsValue";
+
+export function initWatchOldValue(this: Instance, watchConfig: object): WatchOldValue {
+  const watchOldValue = {};
+  for (const key in watchConfig) {
+    watchOldValue[key] = deepClone(getPathsValue.call(this, key.split(".")));
+  }
+
+  return watchOldValue;
+}

package/src/utils/isEmptyObject.ts

@@ -0,0 +1,13 @@
+/**
+ * 判断一个值是否为空对象 `{}`
+ */
+export function isEmptyObject(obj: unknown) {
+  if (
+    typeof obj !== "object" || obj === null || Array.isArray(obj) || obj instanceof Set || obj instanceof Map
+    || obj instanceof WeakSet || obj instanceof WeakMap
+  ) {
+    return false;
+  }
+
+  return Reflect.ownKeys(obj).length === 0;
+}