@ks-web/use 0.0.1

package/dist/onMountedOrActivated/index.d.ts

@@ -0,0 +1 @@
+export declare function onMountedOrActivated(hook: () => any): void;

package/dist/useClickAway/index.d.ts

@@ -0,0 +1,5 @@
+import { Ref } from 'vue';
+export type UseClickAwayOptions = {
+    eventName?: string;
+};
+export declare function useClickAway(target: Element | Ref<Element | undefined> | Array<Element | Ref<Element | undefined>>, listener: EventListener, options?: UseClickAwayOptions): void;

package/dist/useCountDown/index.d.ts

@@ -0,0 +1,20 @@
+export type CurrentTime = {
+    days: number;
+    hours: number;
+    total: number;
+    minutes: number;
+    seconds: number;
+    milliseconds: number;
+};
+export type UseCountDownOptions = {
+    time: number;
+    millisecond?: boolean;
+    onChange?: (current: CurrentTime) => void;
+    onFinish?: () => void;
+};
+export declare function useCountDown(options: UseCountDownOptions): {
+    start: () => void;
+    pause: () => void;
+    reset: (totalTime?: number) => void;
+    current: import("vue").ComputedRef<CurrentTime>;
+};

package/dist/useCustomFieldValue/index.d.ts

@@ -0,0 +1,8 @@
+import { InjectionKey, Ref } from 'vue';
+export type CustomFieldInjectionValue = {
+    customValue: Ref<(() => unknown) | undefined>;
+    resetValidation: () => void;
+    validateWithTrigger: (trigger: 'onBlur' | 'onChange' | 'onSubmit') => void;
+};
+export declare const CUSTOM_FIELD_INJECTION_KEY: InjectionKey<CustomFieldInjectionValue>;
+export declare function useCustomFieldValue(customValue: () => unknown): void;

package/dist/useDebounceThrottle/index.d.ts

@@ -0,0 +1,10 @@
+export declare const debounce: (func: (...arg: any) => void, wait: number, options?: any) => {
+    (this: any): any;
+    cancel: () => void;
+    flush: () => any;
+};
+export declare function throttle(func: (...arg: any) => void, wait: number, options?: any): {
+    (this: any): any;
+    cancel: () => void;
+    flush: () => any;
+};

package/dist/useError/errorClient.d.ts

@@ -0,0 +1,16 @@
+import type { ErrorOptions, ReportOptions } from './types';
+export declare class errorClient implements ErrorOptions {
+    user?: Object | undefined;
+    menu?: String | undefined;
+    type: String | undefined;
+    platform?: String | undefined;
+    constructor(errorOptions: ErrorOptions);
+    addEvent(): void;
+    windowErrorHandler(e: any): void;
+    vueErrorHandler(app: any): void;
+    reactErrorHandler(error: any, info: any): void;
+    handleError(error: any, option: any): void;
+    report(data: ReportOptions): void;
+}
+declare const _default: (errorOptions: ErrorOptions) => errorClient;
+export default _default;

package/dist/useError/index.d.ts

@@ -0,0 +1,2 @@
+import type { ErrorOptions } from "./types";
+export declare function useError(options: ErrorOptions): import("./errorClient").errorClient;

package/dist/useError/types.d.ts

@@ -0,0 +1,15 @@
+export interface ErrorOptions {
+    user?: Object | undefined;
+    menu?: String | undefined;
+    type: String | undefined;
+    platform?: String | undefined;
+}
+export interface ReportOptions {
+    userId: String | undefined;
+    option: Object;
+    userName: String | undefined;
+    menuId: Number | undefined;
+    menuName: String | undefined;
+    platform: String | undefined;
+    error: unknown;
+}

package/dist/useEventListener/index.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+type TargetRef = EventTarget | Ref<EventTarget | undefined>;
+export type UseEventListenerOptions = {
+    target?: TargetRef;
+    capture?: boolean;
+    passive?: boolean;
+};
+export declare function useEventListener<K extends keyof DocumentEventMap>(type: K, listener: (event: DocumentEventMap[K]) => void, options?: UseEventListenerOptions): void;
+export declare function useEventListener(type: string, listener: EventListener, options?: UseEventListenerOptions): void;
+export {};

package/dist/useHttp/http/config.d.ts

@@ -0,0 +1,25 @@
+import type { HttpOptions } from './types';
+export declare const EMPTY_FUNC: () => void;
+export declare const EMPTY_ARRAY: never[];
+export declare const EMPTY_OBJECT: {};
+export declare const REQUEST_METHOD: {
+    get: string;
+    post: string;
+    put: string;
+    patch: string;
+    del: string;
+};
+export declare const DEFAULT_REQUEST_OPTIONS: HttpOptions;
+export declare const responseResultText: {
+    code: string;
+    success: string;
+    data: string;
+    message: string;
+};
+export declare const CONTENT_TYPE: {
+    encoded: string;
+    json: string;
+    form: string;
+    html: string;
+};
+export declare const KUASHENG_TOKEN_KEY = "ks_token";

package/dist/useHttp/http/http.d.ts

@@ -0,0 +1,60 @@
+import type { HttpClient } from '.';
+import type { HttpOptions, httpInstance, HttpInterceptorMap, HttpInterceptorRequest, Params, RequestOptions, HttpConfig, HttpInterceptorResponse, HttpInterceptorReject } from './types';
+import type { CancelToken, AxiosRequestTransformer, AxiosResponseTransformer } from 'axios';
+export declare const getInstance: (options: HttpOptions) => httpInstance;
+export declare function getRequest(httpInstance: HttpClient, url: string, method: string, param?: Params, config?: RequestOptions): Promise<unknown>;
+type HandleParam = {
+    _param: Params;
+    _config: HttpConfig;
+};
+export declare function handleParam(param?: Params, config?: RequestOptions): HandleParam;
+export declare function handleOptions(httpInstance: HttpClient, url: string, method: string, param: Params, config: HttpConfig): {
+    url: string;
+    method: string;
+    baseURL?: string | undefined;
+    transformRequest?: AxiosRequestTransformer | AxiosRequestTransformer[] | undefined;
+    transformResponse?: AxiosResponseTransformer | AxiosResponseTransformer[] | undefined;
+    headers: {};
+    params?: any;
+    paramsSerializer?: import("axios").ParamsSerializerOptions | undefined;
+    data?: any;
+    timeout?: number | undefined;
+    timeoutErrorMessage?: string | undefined;
+    withCredentials?: boolean | undefined;
+    adapter?: (string | import("axios").AxiosAdapter) | (string | import("axios").AxiosAdapter)[] | undefined;
+    auth?: import("axios").AxiosBasicCredentials | undefined;
+    responseType?: import("axios").ResponseType | undefined;
+    responseEncoding?: string | undefined;
+    xsrfCookieName?: string | undefined;
+    xsrfHeaderName?: string | undefined;
+    onUploadProgress?: ((progressEvent: import("axios").AxiosProgressEvent) => void) | undefined;
+    onDownloadProgress?: ((progressEvent: import("axios").AxiosProgressEvent) => void) | undefined;
+    maxContentLength?: number | undefined;
+    validateStatus?: ((status: number) => boolean) | null | undefined;
+    maxBodyLength?: number | undefined;
+    maxRedirects?: number | undefined;
+    maxRate?: number | [number, number] | undefined;
+    beforeRedirect?: ((options: Record<string, any>, responseDetails: {
+        headers: Record<string, string>;
+    }) => void) | undefined;
+    socketPath?: string | null | undefined;
+    httpAgent?: any;
+    httpsAgent?: any;
+    proxy?: false | import("axios").AxiosProxyConfig | undefined;
+    cancelToken?: CancelToken | undefined;
+    decompress?: boolean | undefined;
+    transitional?: import("axios").TransitionalOptions | undefined;
+    signal?: import("axios").GenericAbortSignal | undefined;
+    insecureHTTPParser?: boolean | undefined;
+    env?: {
+        FormData?: (new (...args: any[]) => object) | undefined;
+    } | undefined;
+    formSerializer?: import("axios").FormSerializerOptions | undefined;
+};
+type InterceptorList = Array<{
+    type: 'request' | 'response' | 'rejectRequest' | 'rejectResponse';
+    callback: HttpInterceptorRequest | HttpInterceptorResponse | HttpInterceptorReject;
+}>;
+export declare function mergeInterceptor(httpOptions: HttpOptions, httpInterceptorMap?: HttpInterceptorMap): InterceptorList;
+export declare function runRetry(err: any): Promise<void>;
+export {};

package/dist/useHttp/http/index.d.ts

@@ -0,0 +1,19 @@
+import type { AxiosInstance } from 'axios';
+import type { Params, HttpOptions, RequestOptions, CancelTokenMap } from './types';
+export declare class HttpClient {
+    baseURL: string | undefined;
+    httpOptions: HttpOptions | undefined;
+    http: AxiosInstance;
+    source?: CancelTokenMap;
+    request: (url: string, method: string, param?: Params, requestOptions?: RequestOptions) => Promise<any>;
+    constructor(httpOptions?: HttpOptions);
+    createCancelToken(): CancelTokenMap;
+    get: (url: string, param?: Params, requestOptions?: RequestOptions) => Promise<any>;
+    post: (url: string, param?: Params, requestOptions?: RequestOptions) => Promise<any>;
+    put: (url: string, param?: Params, requestOptions?: RequestOptions) => Promise<any>;
+    patch: (url: string, param?: Params, requestOptions?: RequestOptions) => Promise<any>;
+    del: (url: string, param?: Params, requestOptions?: RequestOptions) => Promise<any>;
+    cancel: (message: string) => void;
+}
+declare const _default: (httpOptions: HttpOptions) => HttpClient;
+export default _default;

package/dist/useHttp/http/types.d.ts

@@ -0,0 +1,58 @@
+import type { AxiosRequestTransformer, AxiosResponseTransformer, AxiosAdapter, AxiosRequestConfig, AxiosInstance, CancelToken, CancelTokenSource, Canceler, AxiosResponse } from 'axios';
+export interface HttpOptions {
+    baseURL?: string;
+    headers?: Record<string, any>;
+    timeout?: number;
+    adapter?: AxiosAdapter;
+    transformRequest?: AxiosRequestTransformer;
+    transformResponse?: AxiosResponseTransformer;
+    validateStatus?: (status: number) => boolean;
+    interceptors?: HttpInterceptorMap;
+    loadingOptions?: {
+        show?: () => void;
+        hide?: () => void;
+    };
+    loading?: boolean;
+    origin?: boolean;
+    casToken?: boolean;
+    appKey?: string | number;
+}
+export interface RequestOptions {
+    baseURL?: string;
+    headers?: Record<string, any>;
+    cancelToken?: CancelToken | CancelTokenSource;
+    ksAdapter?: boolean;
+    failToast?: boolean;
+    loading?: boolean;
+    customHeaders?: boolean;
+    onUploadProgress?: (progressEvent: any) => void;
+    onDownloadProgress?: (progressEvent: any) => void;
+    options?: Record<string, any>;
+    origin?: boolean;
+    appKey?: string | number;
+}
+export type HttpConfig = RequestOptions & HttpOptions;
+export interface HttpInterceptorMap {
+    request?: HttpInterceptorRequest | Array<HttpInterceptorRequest>;
+    response?: HttpInterceptorResponse | Array<HttpInterceptorResponse>;
+    rejectRequest?: HttpInterceptorReject | Array<HttpInterceptorReject>;
+    rejectResponse?: HttpInterceptorReject | Array<HttpInterceptorReject>;
+}
+export type httpInstance = AxiosInstance & {
+    showLoading?: () => void;
+    hideLoading?: () => void;
+};
+export type HttpInterceptorRequest = (value: AxiosRequestConfig) => any;
+export type HttpInterceptorResponse = (value: AxiosResponse) => any;
+export type HttpInterceptorReject = (error: any) => any;
+export interface MergeInterceptorMap {
+    request: Array<HttpInterceptorRequest>;
+    rejectRequest: Array<HttpInterceptorReject>;
+    rejectResponse: Array<HttpInterceptorReject>;
+    response: Array<HttpInterceptorResponse>;
+}
+export type Params<D = any> = Record<string, D>;
+export interface CancelTokenMap {
+    cancel: Canceler;
+    source: CancelToken;
+}

package/dist/useHttp/http/utils.d.ts

@@ -0,0 +1,19 @@
+import type { AxiosResponse, InternalAxiosRequestConfig, AxiosPromise } from 'axios';
+interface CasHeadersTransformOptions {
+    url: string;
+    appkey?: string | number;
+    data?: any;
+}
+export declare const isKuaShengClient: boolean;
+export declare function createCasHeaders(opt: CasHeadersTransformOptions): {
+    method: string;
+    appkey: string | number | undefined;
+    token: string;
+    sign: string;
+    format: string;
+    timestamp: number;
+    'x-webtrace-id': string;
+};
+export declare function casInterceptorResponse(response: AxiosResponse): AxiosResponse<any, any>;
+export declare function createKuaShengAdapter(config: InternalAxiosRequestConfig): AxiosPromise;
+export {};

package/dist/useHttp/index.d.ts

@@ -0,0 +1,3 @@
+import ksHttp from './http';
+export * from './openApi';
+export { ksHttp };

package/dist/useHttp/openApi.d.ts

@@ -0,0 +1,11 @@
+import type { RequestOptions } from './http/types';
+export declare function useHttp(): {
+    cancel: (message: string) => void;
+    createCancelToken: () => import("./http/types").CancelTokenMap;
+    $get: (url: string, appKey: string | number, data: any, config?: RequestOptions | undefined) => Promise<any>;
+    $put: (url: string, appKey: string | number, data: any, config?: RequestOptions | undefined) => Promise<any>;
+    $del: (url: string, appKey: string | number, data: any, config?: RequestOptions | undefined) => Promise<any>;
+    $patch: (url: string, appKey: string | number, data: any, config?: RequestOptions | undefined) => Promise<any>;
+    $post: (url: string, appKey: string | number, data: any, config?: RequestOptions | undefined) => Promise<any>;
+    $http: (url: string, appKey: string | number, data: any, config?: RequestOptions | undefined) => Promise<any>;
+};

package/dist/useMd5/index.d.ts

@@ -0,0 +1,2 @@
+import md5 from 'js-md5';
+export { md5 };

package/dist/usePageVisibility/index.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+type VisibilityState = 'hidden' | 'visible';
+export declare function usePageVisibility(): Ref<VisibilityState>;
+export {};

package/dist/useRect/index.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export declare const useRect: (elementOrRef: Element | Window | Ref<Element | Window | undefined>) => DOMRect;

package/dist/useRelation/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useParent';
+export * from './useChildren';

package/dist/useRelation/useChildren.d.ts

@@ -0,0 +1,9 @@
+import { VNode, InjectionKey, VNodeNormalizedChildren, ComponentPublicInstance, ComponentInternalInstance } from 'vue';
+export declare function flattenVNodes(children: VNodeNormalizedChildren): VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[];
+export declare function sortChildren(parent: ComponentInternalInstance, publicChildren: ComponentPublicInstance[], internalChildren: ComponentInternalInstance[]): void;
+export declare function useChildren<Child extends ComponentPublicInstance = ComponentPublicInstance<{}, any>, ProvideValue = never>(key: InjectionKey<ProvideValue>): {
+    children: Child[];
+    linkChildren: (value?: ProvideValue) => void;
+};

package/dist/useRelation/useParent.d.ts

@@ -0,0 +1,15 @@
+import { InjectionKey, ComponentPublicInstance, ComponentInternalInstance } from 'vue';
+type ParentProvide<T> = T & {
+    link(child: ComponentInternalInstance): void;
+    unlink(child: ComponentInternalInstance): void;
+    children: ComponentPublicInstance[];
+    internalChildren: ComponentInternalInstance[];
+};
+export declare function useParent<T>(key: InjectionKey<ParentProvide<T>>): {
+    parent: ParentProvide<T>;
+    index: import("vue").ComputedRef<number>;
+} | {
+    parent: null;
+    index: import("vue").Ref<number>;
+};
+export {};

package/dist/useScrollParent/index.d.ts

@@ -0,0 +1,5 @@
+import { Ref } from 'vue';
+type ScrollElement = HTMLElement | Window;
+export declare function getScrollParent(el: Element, root?: ScrollElement | undefined): Window | Element | undefined;
+export declare function useScrollParent(el: Ref<Element | undefined>, root?: ScrollElement | undefined): Ref<Window | Element | undefined>;
+export {};

package/dist/useToggle/index.d.ts

@@ -0,0 +1 @@
+export declare function useToggle(defaultValue?: boolean): readonly [import("vue").Ref<boolean>, (value?: boolean) => void];

package/dist/useType/index.d.ts

@@ -0,0 +1,43 @@
+export declare const toString: () => string;
+/**
+ * @method 检测当前类型是否为字符串
+ * @param item 检测当前类型
+ * @returns { Boolean } 如果是字符串则返回true、否则返回false
+ */
+export declare const isString: (item: unknown) => boolean;
+/**
+ * @method 检测当前类型是否为函数
+ * @param item 检测当前类型
+ * @returns { Boolean } 如果是函数则返回true、否则返回false
+ */
+export declare const isFunction: (item: unknown) => boolean;
+/**
+ * @method 检测当前类型是否为空函数
+ * @param item 检测当前类型
+ * @returns { Boolean } 如果是空函数则返回true、否则返回false
+ */
+export declare const isEmptyFunction: (item: () => void | unknown) => boolean;
+/**
+ * @method 检测当前类型是否是数组
+ * @param item 检测当前类型
+ * @returns { Boolean } 如果是数组则返回true、否则返回false
+ */
+export declare const isArray: (item: Array<unknown> | unknown) => boolean;
+/**
+ * @method 检测当前类型是否是空数组
+ * @param item 检测当前类型
+ * @returns { Boolean } 如果为空数组则返回true、否则返回false
+ */
+export declare const isEmptyArray: (item: Array<unknown> | unknown) => boolean;
+/**
+ * @method 检测当前类型是否是对象
+ * @param item 检测当前类型
+ * @returns { Boolean } 如果是对象则返回true、否则返回false
+ */
+export declare const isObject: (item: unknown) => boolean;
+/**
+ * @method 检测当前类型是否是空对象
+ * @param item 检测当前类型
+ * @returns { Boolean } 如果为空的对象则返回true、否则返回false
+ */
+export declare const isEmptyObject: (item: unknown) => boolean;

package/dist/useWaterMark/index.d.ts

@@ -0,0 +1,8 @@
+export declare const customWatermark: (text?: string | any[], el?: string, color?: string, rotate?: number) => void;
+/**
+ * 添加水印方法
+ * @param {string} employeeNumber 工号
+ * @param {sting} el css选择器
+ * @param {string} color 水印文字颜色（格式rgba）
+ */
+export declare function useWaterMark(employeeNumber: string, el?: string, color?: string): void;

package/dist/useWindowSize/index.d.ts

@@ -0,0 +1,5 @@
+import { Ref } from 'vue';
+export declare function useWindowSize(): {
+    width: Ref<number>;
+    height: Ref<number>;
+};

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const inBrowser: boolean;
+export declare const supportsPassive = true;
+export declare function raf(fn: FrameRequestCallback): number;
+export declare function cancelRaf(id: number): void;
+export declare function doubleRaf(fn: FrameRequestCallback): void;

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@ks-web/use",
+  "version": "0.0.1",
+  "description": "Vant Composition API",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.mjs",
+  "typings": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.esm.mjs",
+      "require": "./dist/index.cjs.js"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "rimraf ./dist",
+    "dev": "node ./build.js -w",
+    "build:types": "tsc -p ./tsconfig.json --emitDeclarationOnly",
+    "build:bundle": "node ./build.js",
+    "build": "pnpm clean && pnpm build:bundle && pnpm build:types",
+    "release": "pnpm build && release-it",
+    "prepare": "pnpm build"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vant-ui/vant.git",
+    "directory": "packages/vant-use"
+  },
+  "bugs": "https://github.com/vant-ui/vant/issues",
+  "author": "chenjiahan",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/js-md5": "0.7.0",
+    "@types/qs": "6.9.7",
+    "axios": "1.3.3",
+    "esbuild": "0.16.10",
+    "js-md5": "0.7.3",
+    "qs": "6.11.0",
+    "release-it": "^15.4.1",
+    "rimraf": "^4.0.4",
+    "typescript": "^4.8.2",
+    "vue": "^3.2.45"
+  },
+  "release-it": {
+    "git": {
+      "tag": false,
+      "commitMessage": "release: @vant/use ${version}"
+    }
+  }
+}