@pawover/kit 0.0.0-alpha.2 → 0.0.0-alpha.20

package/dist/enums.d.ts

@@ -0,0 +1,24 @@
+//#region src/enums/index.d.ts
+interface BreakPointTokens {
+  XS: number;
+  XSMin: number;
+  XSMax: number;
+  SM: number;
+  SMMin: number;
+  SMMax: number;
+  MD: number;
+  MDMin: number;
+  MDMax: number;
+  LG: number;
+  LGMin: number;
+  LGMax: number;
+  XL: number;
+  XLMin: number;
+  XLMax: number;
+  XXL: number;
+  XXLMin: number;
+}
+/** 屏幕响应断点 token 配置 */
+declare const BREAK_POINT_TOKENS: BreakPointTokens;
+//#endregion
+export { BREAK_POINT_TOKENS, BreakPointTokens };

package/dist/enums.js

@@ -0,0 +1,24 @@
+//#region src/enums/index.ts
+/** 屏幕响应断点 token 配置 */
+const BREAK_POINT_TOKENS = {
+	XS: 576,
+	XSMin: 576,
+	XSMax: 767,
+	SM: 768,
+	SMMin: 768,
+	SMMax: 991,
+	MD: 992,
+	MDMin: 992,
+	MDMax: 1199,
+	LG: 1200,
+	LGMin: 1200,
+	LGMax: 1599,
+	XL: 1600,
+	XLMin: 1600,
+	XLMax: 1919,
+	XXL: 1920,
+	XXLMin: 1920
+};
+
+//#endregion
+export { BREAK_POINT_TOKENS };

package/dist/hooks-alova.d.ts

@@ -0,0 +1,22 @@
+import * as alova_client0 from "alova/client";
+import { AlovaFrontMiddlewareContext, AlovaMethodHandler, CompleteHandler, ErrorHandler, RequestHookConfig, SuccessHandler, WatcherHookConfig } from "alova/client";
+import { AlovaGenerics, Method } from "alova";
+
+//#region src/hooks/alova/useAlovaRequest.d.ts
+interface HookConfig$1<AG extends AlovaGenerics, Args extends any[]> extends RequestHookConfig<AG, Args> {
+  onBeforeRequest?: (context: AlovaFrontMiddlewareContext<AG, Args>) => void;
+  onSuccess?: SuccessHandler<AG, Args>;
+  onError?: ErrorHandler<AG, Args>;
+  onComplete?: CompleteHandler<AG, Args>;
+}
+declare function useAlovaRequest<AG extends AlovaGenerics, Args extends any[] = any[]>(methodHandler: Method<AG> | AlovaMethodHandler<AG, Args>, hookConfig?: HookConfig$1<AG, Args> | undefined): alova_client0.UseHookExposure<AG, Args, unknown>;
+//#endregion
+//#region src/hooks/alova/useAlovaWatcher.d.ts
+interface HookConfig<AG extends AlovaGenerics, Args extends any[]> extends WatcherHookConfig<AG, Args> {
+  onSuccess?: SuccessHandler<AG, Args>;
+  onError?: ErrorHandler<AG, Args>;
+  onComplete?: CompleteHandler<AG, Args>;
+}
+declare function useAlovaWatcher<AG extends AlovaGenerics, Args extends any[] = any[]>(methodHandler: Method<AG> | AlovaMethodHandler<AG, Args>, watchingStates: AG["StatesExport"]["Watched"][], hookConfig?: HookConfig<AG, Args>): alova_client0.UseHookExposure<AG, Args, unknown>;
+//#endregion
+export { useAlovaRequest, useAlovaWatcher };

package/dist/hooks-alova.js

@@ -0,0 +1,38 @@
+import { useRequest, useWatcher } from "alova/client";
+
+//#region src/hooks/alova/useAlovaRequest.ts
+function useAlovaRequest(methodHandler, hookConfig) {
+	const config = hookConfig || {};
+	config.immediate ?? (config.immediate = true);
+	if (config.onBeforeRequest) {
+		const middleware = config.middleware;
+		config.middleware = async (context, next) => {
+			config.onBeforeRequest?.(context);
+			if (middleware) {
+				async function run() {
+					await next();
+				}
+				await middleware?.(context, run);
+			} else await next();
+		};
+	}
+	const exposure = useRequest(methodHandler, config);
+	if (config.onSuccess) exposure.onSuccess(config.onSuccess);
+	if (config.onError) exposure.onError(config.onError);
+	if (config.onComplete) exposure.onComplete(config.onComplete);
+	return exposure;
+}
+
+//#endregion
+//#region src/hooks/alova/useAlovaWatcher.ts
+function useAlovaWatcher(methodHandler, watchingStates, hookConfig = {}) {
+	const config = hookConfig || {};
+	const exposure = useWatcher(methodHandler, watchingStates, config);
+	if (config.onSuccess) exposure.onSuccess(config.onSuccess);
+	if (config.onError) exposure.onError(config.onError);
+	if (config.onComplete) exposure.onComplete(config.onComplete);
+	return exposure;
+}
+
+//#endregion
+export { useAlovaRequest, useAlovaWatcher };

package/dist/hooks-react.d.ts

@@ -0,0 +1,87 @@
+import * as react0 from "react";
+import { DependencyList, EffectCallback } from "react";
+import { Breakpoint } from "@pawover/types";
+
+//#region src/hooks/react/useCreation.d.ts
+
+/**
+ * useCreation
+ * @reference https://ahooks.js.org/zh-CN/hooks/use-creation
+ *
+ * @template T
+ * @param {() => T} factory
+ * @param {DependencyList} deps
+ */
+declare function useCreation<T>(factory: () => T, deps: DependencyList): T;
+//#endregion
+//#region src/hooks/react/useLatest.d.ts
+/**
+ * 返回当前最新值的 Hook
+ * @reference https://ahooks.js.org/zh-CN/hooks/use-latest
+ *
+ * @template T
+ * @param {T} value
+ */
+declare function useLatest<T>(value: T): react0.RefObject<T>;
+//#endregion
+//#region src/hooks/react/useMount.d.ts
+type MountCallback = EffectCallback | AsyncFunc;
+/**
+ * 在组件初始化时执行的 Hook
+ * - 即使在严格模式下也只执行一次
+ * @reference https://ahooks.js.org/hooks/use-mount
+ *
+ * @param {MountCallback} effect 副作用函数
+ */
+declare function useMount(effect: MountCallback): void;
+//#endregion
+//#region src/enums/index.d.ts
+interface BreakPointTokens {
+  XS: number;
+  XSMin: number;
+  XSMax: number;
+  SM: number;
+  SMMin: number;
+  SMMax: number;
+  MD: number;
+  MDMin: number;
+  MDMax: number;
+  LG: number;
+  LGMin: number;
+  LGMax: number;
+  XL: number;
+  XLMin: number;
+  XLMax: number;
+  XXL: number;
+  XXLMin: number;
+}
+//#endregion
+//#region src/hooks/react/useResponsive.d.ts
+type ResponsiveValues = Record<Breakpoint, boolean>;
+interface ResponsiveHookOptions {
+  /**
+   * 紧凑布局断点
+   * - 低于此断点时使用紧凑布局
+   * @default "xl"
+   */
+  compactBreakPoint?: Breakpoint;
+  /** 屏幕响应断点 token 配置 */
+  breakPointTokens?: BreakPointTokens;
+}
+declare function useResponsive(options?: ResponsiveHookOptions): {
+  responsive: ResponsiveValues;
+  current: Breakpoint;
+  isCompact: boolean;
+  breakPointTokens: BreakPointTokens;
+};
+//#endregion
+//#region src/hooks/react/useUnmount.d.ts
+/**
+ * 在组件卸载时执行的 Hook
+ * @reference https://ahooks.js.org/zh-CN/hooks/use-unmount
+ *
+ * @param {Func} effect 副作用函数
+ */
+declare function useUnmount(effect: Func): void;
+//#endregion
+export { useCreation, useLatest, useMount, useResponsive, useUnmount };

package/dist/hooks-react.js

@@ -0,0 +1,295 @@
+import { useEffect, useRef, useState } from "react";
+
+//#region src/utils/typeof/types.ts
+const prototypeStrings = {
+	string: "[object String]",
+	number: "[object Number]",
+	boolean: "[object Boolean]",
+	object: "[object Object]",
+	array: "[object Array]",
+	bigInt: "[object BigInt]",
+	symbol: "[object Symbol]",
+	function: "[object Function]",
+	generatorFunction: "[object GeneratorFunction]",
+	asyncFunction: "[object AsyncFunction]",
+	promise: "[object Promise]",
+	null: "[object Null]",
+	undefined: "[object Undefined]",
+	date: "[object Date]",
+	regExp: "[object RegExp]",
+	error: "[object Error]",
+	file: "[object File]",
+	map: "[object Map]",
+	weakMap: "[object WeakMap]",
+	set: "[object Set]",
+	weakSet: "[object WeakSet]",
+	window: "[object Window]",
+	webSocket: "[object WebSocket]",
+	URLSearchParams: "[object URLSearchParams]"
+};
+function resolvePrototypeString(value) {
+	return Object.prototype.toString.call(value);
+}
+
+//#endregion
+//#region src/utils/typeof/isEqual.ts
+/**
+* 判断给定的值是否相等
+* @reference https://github.com/radashi-org/radashi/blob/main/src/typed/isEqual.ts
+*
+* @param {T} x
+* @param {T} y
+*/
+function isEqual(x, y) {
+	if (Object.is(x, y)) return true;
+	if (x instanceof Date && y instanceof Date) return x.getTime() === y.getTime();
+	if (x instanceof RegExp && y instanceof RegExp) return x.toString() === y.toString();
+	if (typeof x !== "object" || x === null || typeof y !== "object" || y === null) return false;
+	const keysX = Reflect.ownKeys(x);
+	const keysY = Reflect.ownKeys(y);
+	if (keysX.length !== keysY.length) return false;
+	for (const key of keysX) {
+		if (!Reflect.has(y, key)) return false;
+		if (!isEqual(x[key], y[key])) return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region src/utils/typeof/isFunction.ts
+function isFunction(value) {
+	return [
+		prototypeStrings.function,
+		prototypeStrings.generatorFunction,
+		prototypeStrings.asyncFunction
+	].includes(resolvePrototypeString(value));
+}
+
+//#endregion
+//#region src/utils/typeof/isObject.ts
+function isObject(value) {
+	return resolvePrototypeString(value) === prototypeStrings.object;
+}
+
+//#endregion
+//#region src/utils/typeof/isPromise.ts
+function isPromise(value) {
+	return resolvePrototypeString(value) === prototypeStrings.promise;
+}
+
+//#endregion
+//#region src/utils/typeof/isPromiseLike.ts
+function isPromiseLike(value) {
+	return isPromise(value) || isObject(value) && isFunction(value["then"]);
+}
+
+//#endregion
+//#region src/utils/object/objectKeys.ts
+/**
+* 返回对象的可枚举属性和方法的名称
+* - `Object.keys` 始终返回 `string[]` 类型，此函数可以返回具体类型
+*
+* @param obj 对象
+*/
+function objectKeys(obj) {
+	return Object.keys(obj);
+}
+
+//#endregion
+//#region node_modules/.pnpm/radashi@12.7.1/node_modules/radashi/dist/radashi.js
+function assign(initial, override) {
+	if (!initial || !override) return initial ?? override ?? {};
+	const proto = Object.getPrototypeOf(initial);
+	const merged = proto ? { ...initial } : Object.assign(Object.create(proto), initial);
+	for (const key of Object.keys(override)) merged[key] = isPlainObject(initial[key]) && isPlainObject(override[key]) ? assign(initial[key], override[key]) : override[key];
+	return merged;
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null || Object.getPrototypeOf(prototype) === null;
+}
+
+//#endregion
+//#region src/utils/object/objectAssign.ts
+const objectAssign = assign;
+
+//#endregion
+//#region src/hooks/react/useCreation.ts
+/**
+* useCreation
+* @reference https://ahooks.js.org/zh-CN/hooks/use-creation
+*
+* @template T
+* @param {() => T} factory
+* @param {DependencyList} deps
+*/
+function useCreation(factory, deps) {
+	const { current } = useRef({
+		deps,
+		result: void 0,
+		isInitialized: false
+	});
+	if (current.isInitialized === false || !isEqual(current.deps, deps)) {
+		current.deps = deps;
+		current.result = factory();
+		current.isInitialized = true;
+	}
+	return current.result;
+}
+
+//#endregion
+//#region src/hooks/react/useLatest.ts
+/**
+* 返回当前最新值的 Hook
+* @reference https://ahooks.js.org/zh-CN/hooks/use-latest
+*
+* @template T
+* @param {T} value
+*/
+function useLatest(value) {
+	const ref = useRef(value);
+	ref.current = value;
+	return ref;
+}
+
+//#endregion
+//#region src/hooks/react/useMount.ts
+/**
+* 在组件初始化时执行的 Hook
+* - 即使在严格模式下也只执行一次
+* @reference https://ahooks.js.org/hooks/use-mount
+*
+* @param {MountCallback} effect 副作用函数
+*/
+function useMount(effect) {
+	if (!isFunction(effect)) console.error(`useMount expected parameter is a function, but got ${typeof effect}`);
+	const isMountedRef = useRef(false);
+	const effectRef = useLatest(effect);
+	useEffect(() => {
+		if (isMountedRef.current) return;
+		isMountedRef.current = true;
+		const result = effectRef.current?.();
+		if (isPromiseLike(result)) return;
+		return result;
+	}, []);
+}
+
+//#endregion
+//#region src/enums/index.ts
+/** 屏幕响应断点 token 配置 */
+const BREAK_POINT_TOKENS = {
+	XS: 576,
+	XSMin: 576,
+	XSMax: 767,
+	SM: 768,
+	SMMin: 768,
+	SMMax: 991,
+	MD: 992,
+	MDMin: 992,
+	MDMax: 1199,
+	LG: 1200,
+	LGMin: 1200,
+	LGMax: 1599,
+	XL: 1600,
+	XLMin: 1600,
+	XLMax: 1919,
+	XXL: 1920,
+	XXLMin: 1920
+};
+
+//#endregion
+//#region src/hooks/react/useResponsive.ts
+const subscriberList = /* @__PURE__ */ new Set();
+const { XS, SM, MD, LG, XL, XXL } = BREAK_POINT_TOKENS;
+const defaultResponsiveValues = {
+	xxl: false,
+	xl: false,
+	lg: false,
+	md: false,
+	sm: false,
+	xs: false
+};
+let responsiveConfig = {
+	xxl: XXL,
+	xl: XL,
+	lg: LG,
+	md: MD,
+	sm: SM,
+	xs: XS
+};
+let responsiveValues = { ...defaultResponsiveValues };
+function useResponsive(options) {
+	const { compactBreakPoint = "xl", breakPointTokens = {} } = options || {};
+	const tokens = objectAssign(BREAK_POINT_TOKENS, breakPointTokens);
+	responsiveConfig = {
+		xxl: tokens.XXL,
+		xl: tokens.XL,
+		lg: tokens.LG,
+		md: tokens.MD,
+		sm: tokens.SM,
+		xs: tokens.XS
+	};
+	calculate();
+	const [responsive, setResponsive] = useState(responsiveValues);
+	const isCompact = !responsive[compactBreakPoint];
+	const current = objectKeys(defaultResponsiveValues).find((key) => responsive[key] === true) || "xs";
+	useEffect(() => {
+		addListener();
+		const subscriber = () => {
+			setResponsive(responsiveValues);
+		};
+		subscriberList.add(subscriber);
+		return () => {
+			subscriberList.delete(subscriber);
+			if (subscriberList.size === 0) removeListener();
+		};
+	}, []);
+	return {
+		responsive,
+		current,
+		isCompact,
+		breakPointTokens: tokens
+	};
+}
+function resizeListener() {
+	const oldInfo = responsiveValues;
+	calculate();
+	if (oldInfo === responsiveValues) return;
+	for (const subscriber of subscriberList) subscriber();
+}
+function addListener() {
+	window.addEventListener("resize", resizeListener);
+}
+function removeListener() {
+	window.removeEventListener("resize", resizeListener);
+}
+function calculate() {
+	const width = window.innerWidth;
+	const newValues = { ...defaultResponsiveValues };
+	let shouldUpdate = false;
+	for (const key of objectKeys(responsiveConfig)) {
+		newValues[key] = width >= responsiveConfig[key];
+		if (newValues[key] !== responsiveValues[key]) shouldUpdate = true;
+	}
+	if (shouldUpdate) responsiveValues = newValues;
+}
+
+//#endregion
+//#region src/hooks/react/useUnmount.ts
+/**
+* 在组件卸载时执行的 Hook
+* @reference https://ahooks.js.org/zh-CN/hooks/use-unmount
+*
+* @param {Func} effect 副作用函数
+*/
+function useUnmount(effect) {
+	if (!isFunction(effect)) console.error(`useUnmount expected parameter is a function, got ${typeof effect}`);
+	const effectRef = useLatest(effect);
+	useEffect(() => () => {
+		effectRef.current?.();
+	}, []);
+}
+
+//#endregion
+export { useCreation, useLatest, useMount, useResponsive, useUnmount };