jk-vue-comps 0.1.0

package/dist/types/index.d.ts

@@ -0,0 +1,248 @@
+import * as comps from './components';
+import * as utils from './utils';
+export * from './components';
+export * from './utils';
+declare const JKVUEComps: {
+    Utils: {
+        is: typeof import("./utils/is");
+        propTypes: typeof import("./utils/vuePropTypes");
+        timeZone: typeof import("./utils/timeZone");
+        withInstall: typeof import("./utils/withInstall");
+    };
+    Comps: typeof comps;
+    evalPro(str: string): any;
+    filterInputNum(e: string | number, type?: "int" | "float", maxDecimal?: number): string;
+    generateHandleInputFn<T extends object, K extends keyof T>(obj: T, key: K, fn?: (() => void) | undefined, type?: "int" | "float", maxDecimal?: number): (e: ChangeEvent) => void;
+    renderHtmlStr(html: string): string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+    getWebsiteUrl(): string;
+    getRouterParams(): Recordable<any> | undefined;
+    is(val: unknown, type: string): boolean;
+    isDef<T_1 = unknown>(val?: T_1 | undefined): val is T_1;
+    isUnDef<T_2 = unknown>(val?: T_2 | undefined): val is T_2;
+    isObject(val: any): val is Record<any, any>;
+    isDate(val: unknown): val is Date;
+    isNull(val: unknown): val is null;
+    isNullAndUnDef(val: unknown): val is null | undefined;
+    isNullOrUnDef(val: unknown): val is null | undefined;
+    isNumber(val: unknown): val is number;
+    isString(val: unknown): val is string;
+    isFunction(val: unknown): val is Function;
+    isBoolean(val: unknown): val is boolean;
+    isRegExp(val: unknown): val is RegExp;
+    isArray(val: any): val is any[];
+    isEmpty<T_3 = unknown>(val: T_3): val is T_3;
+    isPromise<T_4 = any>(val: unknown): val is Promise<T_4>;
+    isPromiseLink<T_5>(it: T_5 | PromiseLike<T_5>): it is PromiseLike<T_5>;
+    isWindow(val: any): val is Window;
+    isElement(val: unknown): val is Element;
+    isMap(val: unknown): val is Map<any, any>;
+    isUrl(path: string): boolean;
+    isValidPhoneNumber(phoneNumber: string): boolean;
+    isInMobileBrowser(): false | RegExpMatchArray | null;
+    isZhLang(lang: string): boolean;
+    isEdgeBrowser(): boolean;
+    isServer: boolean;
+    isClient: boolean;
+    isIp: (ip: string) => boolean;
+    isEmail: (email: string) => boolean;
+    isHtmlStr: (str: string) => boolean;
+    propTypes: typeof import("./utils/vuePropTypes").default;
+    timeZoneOptions: utils.TimeZoneItem[];
+    withInstall<T_6>(component: T_6, alias?: string | undefined): T_6 & import("vue").Plugin;
+    toGoogleAuth(clientId: string, redirectUri: string): void;
+    GoogleAuth: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+            clientId: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+                default: string;
+            };
+            redirectUri: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+                default: string;
+            };
+        }>> & {
+            onCallback?: ((_data: {
+                code: string;
+            }) => any) | undefined;
+            onRejectCallback?: ((_data: any) => any) | undefined;
+        }, {
+            domId: string;
+            isHidden: import("vue").Ref<boolean>;
+            startCheck: () => void;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            callback: (_data: {
+                code: string;
+            }) => true;
+            rejectCallback: (_data: any) => true;
+        }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+            clientId: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+                default: string;
+            };
+            redirectUri: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+                default: string;
+            };
+        }>> & {
+            onCallback?: ((_data: {
+                code: string;
+            }) => any) | undefined;
+            onRejectCallback?: ((_data: any) => any) | undefined;
+        }, {
+            clientId: string;
+            redirectUri: string;
+        }, true, {}, import("vue").SlotsType<{
+            default: {
+                startCheck: () => void;
+            };
+        }>, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            clientId: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+                default: string;
+            };
+            redirectUri: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+                default: string;
+            };
+        }>> & {
+            onCallback?: ((_data: {
+                code: string;
+            }) => any) | undefined;
+            onRejectCallback?: ((_data: any) => any) | undefined;
+        }, {
+            domId: string;
+            isHidden: import("vue").Ref<boolean>;
+            startCheck: () => void;
+        }, {}, {}, {}, {
+            clientId: string;
+            redirectUri: string;
+        }>;
+        __isFragment?: undefined;
+        __isTeleport?: undefined;
+        __isSuspense?: undefined;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        clientId: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+            default: string;
+        };
+        redirectUri: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+            default: string;
+        };
+    }>> & {
+        onCallback?: ((_data: {
+            code: string;
+        }) => any) | undefined;
+        onRejectCallback?: ((_data: any) => any) | undefined;
+    }, {
+        domId: string;
+        isHidden: import("vue").Ref<boolean>;
+        startCheck: () => void;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        callback: (_data: {
+            code: string;
+        }) => true;
+        rejectCallback: (_data: any) => true;
+    }, string, {
+        clientId: string;
+        redirectUri: string;
+    }, {}, string, import("vue").SlotsType<{
+        default: {
+            startCheck: () => void;
+        };
+    }>> & (import("vue").VNodeProps & (import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & ({
+        readonly toGoogleAuth: typeof comps.toGoogleAuth;
+    } & import("vue").Plugin)));
+    toTelegramAuth(botId: number, toPath: string): void;
+    getTelegramAuthUrlParams(): any;
+    TelegramAuth: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+            botId: import("vue-types").VueTypeValidableDef<number, import("node_modules/vue-types/dist/types").ValidatorFunction<number>> & {
+                default: number;
+            };
+            toPath: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+                default: string;
+            };
+        }>> & {
+            onCallback?: ((_user: comps.TgUserData) => any) | undefined;
+            onRejectCallback?: (() => any) | undefined;
+        }, {
+            domId: string;
+            startCheck: () => void;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            callback: (_user: comps.TgUserData) => true;
+            rejectCallback: () => true;
+        }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+            botId: import("vue-types").VueTypeValidableDef<number, import("node_modules/vue-types/dist/types").ValidatorFunction<number>> & {
+                default: number;
+            };
+            toPath: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+                default: string;
+            };
+        }>> & {
+            onCallback?: ((_user: comps.TgUserData) => any) | undefined;
+            onRejectCallback?: (() => any) | undefined;
+        }, {
+            botId: number;
+            toPath: string;
+        }, true, {}, import("vue").SlotsType<{
+            default: {
+                startCheck: () => void;
+            };
+        }>, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            botId: import("vue-types").VueTypeValidableDef<number, import("node_modules/vue-types/dist/types").ValidatorFunction<number>> & {
+                default: number;
+            };
+            toPath: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+                default: string;
+            };
+        }>> & {
+            onCallback?: ((_user: comps.TgUserData) => any) | undefined;
+            onRejectCallback?: (() => any) | undefined;
+        }, {
+            domId: string;
+            startCheck: () => void;
+        }, {}, {}, {}, {
+            botId: number;
+            toPath: string;
+        }>;
+        __isFragment?: undefined;
+        __isTeleport?: undefined;
+        __isSuspense?: undefined;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        botId: import("vue-types").VueTypeValidableDef<number, import("node_modules/vue-types/dist/types").ValidatorFunction<number>> & {
+            default: number;
+        };
+        toPath: import("vue-types").VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+            default: string;
+        };
+    }>> & {
+        onCallback?: ((_user: comps.TgUserData) => any) | undefined;
+        onRejectCallback?: (() => any) | undefined;
+    }, {
+        domId: string;
+        startCheck: () => void;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        callback: (_user: comps.TgUserData) => true;
+        rejectCallback: () => true;
+    }, string, {
+        botId: number;
+        toPath: string;
+    }, {}, string, import("vue").SlotsType<{
+        default: {
+            startCheck: () => void;
+        };
+    }>> & (import("vue").VNodeProps & (import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & ({
+        readonly toTelegramAuth: typeof comps.toTelegramAuth;
+        readonly getTelegramAuthUrlParams: typeof comps.getTelegramAuthUrlParams;
+    } & import("vue").Plugin)));
+};
+export default JKVUEComps;

package/dist/types/utils/index.d.ts

@@ -0,0 +1,24 @@
+import * as is from './is';
+import * as propTypes from './vuePropTypes';
+import * as timeZone from './timeZone';
+import * as withInstall from './withInstall';
+export * from './is';
+export * from './vuePropTypes';
+export * from './timeZone';
+export * from './withInstall';
+export declare const Utils: {
+    is: typeof is;
+    propTypes: typeof propTypes;
+    timeZone: typeof timeZone;
+    withInstall: typeof withInstall;
+};
+export declare function evalPro(str: string): any;
+export declare function filterInputNum(e: string | number, type?: 'int' | 'float', maxDecimal?: number): string;
+/** 生成输入数字过滤函数 */
+export declare function generateHandleInputFn<T extends object, K extends keyof T>(obj: T, key: K, fn?: () => void, type?: 'float' | 'int', maxDecimal?: number): (e: ChangeEvent) => void;
+/** 渲染Html字符串片段 */
+export declare function renderHtmlStr(html: string): string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export declare function getWebsiteUrl(): string;
+export declare function getRouterParams(): Recordable<any> | undefined;

package/dist/types/utils/is.d.ts

@@ -0,0 +1,59 @@
+export declare function is(val: unknown, type: string): boolean;
+/** 是否undefined */
+export declare function isDef<T = unknown>(val?: T): val is T;
+/** 是否不是undefined */
+export declare function isUnDef<T = unknown>(val?: T): val is T;
+/** 是否对象  */
+export declare function isObject(val: any): val is Record<any, any>;
+/** 是否Date */
+export declare function isDate(val: unknown): val is Date;
+/** 是否null */
+export declare function isNull(val: unknown): val is null;
+/** 是否null && 不是undefined */
+export declare function isNullAndUnDef(val: unknown): val is null | undefined;
+/** 是否null || 不是undefined */
+export declare function isNullOrUnDef(val: unknown): val is null | undefined;
+/** 是否数字（NaN也是数字） */
+export declare function isNumber(val: unknown): val is number;
+/** 是否字符串 */
+export declare function isString(val: unknown): val is string;
+/** 是否函数 */
+export declare function isFunction(val: unknown): val is Function;
+/** 是否布尔 */
+export declare function isBoolean(val: unknown): val is boolean;
+/** 是否正则 */
+export declare function isRegExp(val: unknown): val is RegExp;
+/** 是否数组 */
+export declare function isArray(val: any): val is Array<any>;
+/** 是否空 */
+export declare function isEmpty<T = unknown>(val: T): val is T;
+/** 是否Promise */
+export declare function isPromise<T = any>(val: unknown): val is Promise<T>;
+/** 是否PromiseLink */
+export declare function isPromiseLink<T>(it: T | PromiseLike<T>): it is PromiseLike<T>;
+/** 是否Window */
+export declare function isWindow(val: any): val is Window;
+/** 是否Element */
+export declare function isElement(val: unknown): val is Element;
+/** 是否Map */
+export declare function isMap(val: unknown): val is Map<any, any>;
+/** 是否服务端渲染，没有window对象 */
+export declare const isServer: boolean;
+/** 是否客户端，window对象不为undefined */
+export declare const isClient: boolean;
+/** 是否url */
+export declare function isUrl(path: string): boolean;
+/** 是否Ip */
+export declare const isIp: (ip: string) => boolean;
+/** 是否邮箱 */
+export declare const isEmail: (email: string) => boolean;
+/** 是否号码 */
+export declare function isValidPhoneNumber(phoneNumber: string): boolean;
+/** 是否移动端浏览器 */
+export declare function isInMobileBrowser(): false | RegExpMatchArray | null;
+/** 是否中文 */
+export declare function isZhLang(lang: string): boolean;
+/** 是否Edge浏览器 */
+export declare function isEdgeBrowser(): boolean;
+/** 是否html字符串 */
+export declare const isHtmlStr: (str: string) => boolean;

package/dist/types/utils/timeZone.d.ts

@@ -0,0 +1,9 @@
+/** 时区项类型 */
+export type TimeZoneItem = {
+    label: string;
+    enLabel: string;
+    value: string;
+    tzNum: number;
+};
+/** 时区列表 */
+export declare const timeZoneOptions: TimeZoneItem[];

package/dist/types/utils/vuePropTypes.d.ts

@@ -0,0 +1,65 @@
+import type { CSSProperties, VNode, VNodeChild } from 'vue';
+import * as VueTypes from 'vue-types';
+declare const VuePropTypes_base: {
+    new (): {};
+    defaults: Partial<import("node_modules/vue-types/dist/types").VueTypesDefaults>;
+    sensibleDefaults: boolean | Partial<import("node_modules/vue-types/dist/types").VueTypesDefaults>;
+    config: import("node_modules/vue-types/dist/types").VueTypesConfig;
+    readonly any: VueTypes.VueTypeValidableDef<any, import("node_modules/vue-types/dist/types").ValidatorFunction<any>>;
+    readonly func: VueTypes.VueTypeValidableDef<(...args: any[]) => any, import("node_modules/vue-types/dist/types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    readonly bool: VueTypes.VueTypeValidableDef<boolean, import("node_modules/vue-types/dist/types").ValidatorFunction<boolean>>;
+    readonly string: VueTypes.VueTypeValidableDef<string, import("node_modules/vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    readonly number: VueTypes.VueTypeValidableDef<number, import("node_modules/vue-types/dist/types").ValidatorFunction<number>> & {
+        default: number;
+    };
+    readonly array: VueTypes.VueTypeValidableDef<unknown[], import("node_modules/vue-types/dist/types").ValidatorFunction<unknown[]>> & {
+        default: () => unknown[];
+    };
+    readonly object: VueTypes.VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("node_modules/vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    readonly integer: VueTypes.VueTypeDef<number> & {
+        default: number;
+    };
+    readonly symbol: VueTypes.VueTypeDef<symbol>;
+    readonly nullable: import("node_modules/vue-types/dist/types").PropOptions<null, null>;
+    readonly custom: typeof VueTypes.custom;
+    readonly oneOf: typeof VueTypes.oneOf;
+    readonly instanceOf: typeof VueTypes.instanceOf;
+    readonly oneOfType: typeof VueTypes.oneOfType;
+    readonly arrayOf: typeof VueTypes.arrayOf;
+    readonly objectOf: typeof VueTypes.objectOf;
+    readonly shape: typeof VueTypes.shape;
+    extend<T = any>(props: import("node_modules/vue-types/dist/types").ExtendProps<any> | import("node_modules/vue-types/dist/types").ExtendProps<any>[]): T;
+    utils: {
+        validate<T_1, U>(value: T_1, type: U): boolean;
+        toType<T_2 = unknown>(name: string, obj: import("node_modules/vue-types/dist/types").PropOptions<T_2, T_2>, validable?: boolean | undefined): VueTypes.VueTypeDef<T_2> | VueTypes.VueTypeValidableDef<T_2, import("node_modules/vue-types/dist/types").ValidatorFunction<T_2>>;
+    };
+};
+declare class VuePropTypes extends VuePropTypes_base {
+    static vueTypes: typeof VueTypes;
+    static anyType: <T = any>() => VueTypes.VueTypeValidableDef<T, import("node_modules/vue-types/dist/types").ValidatorFunction<T>>;
+    static stringType: <T extends string = string>() => VueTypes.VueTypeValidableDef<T, import("node_modules/vue-types/dist/types").ValidatorFunction<T>>;
+    static boolType: () => VueTypes.VueTypeValidableDef<boolean, import("node_modules/vue-types/dist/types").ValidatorFunction<boolean>>;
+    static numberType: <T extends number = number>() => VueTypes.VueTypeValidableDef<T, import("node_modules/vue-types/dist/types").ValidatorFunction<T>>;
+    static funcType: <T extends (...args: any[]) => any>() => VueTypes.VueTypeValidableDef<T, import("node_modules/vue-types/dist/types").ValidatorFunction<T>>;
+    static get style(): VueTypes.VueTypeValidableDef<string | CSSProperties, import("node_modules/vue-types/dist/types").ValidatorFunction<string | CSSProperties>>;
+    static get vueNode(): VueTypes.VueTypeValidableDef<VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | VNodeChild, import("node_modules/vue-types/dist/types").ValidatorFunction<VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | VNodeChild>>;
+}
+/** vue-types类型工具 */
+export declare const propTypes: typeof VuePropTypes;
+export default VuePropTypes;

package/dist/types/utils/withInstall.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vue';
+/** 得到install方法 */
+export declare function withInstall<T>(component: T, alias?: string): T & Plugin;

package/dist/utils/index.js

@@ -0,0 +1,48 @@
+import "vue";
+import { i as e, n as r, l as t, v as o, d as n, a as l, C as m, s as p, y as f, o as u, k as g, D as b, A as d, x, t as U, e as w, f as D, g as N, h as E, c as I, p as P, q as h, m as y, u as B, j as S, b as c, w as v, z as A, r as H, B as O } from "../chunks/is-bvgc5qxU.js";
+import { p as k } from "../chunks/vuePropTypes-zy5Iwonj.js";
+import { t as F } from "../chunks/timeZone-CYGfhbdm.js";
+import { w as M } from "../chunks/withInstall-b5j1glXj.js";
+import { U as W, e as Z, f as q, g as z, b as T, a as V, r as G } from "../chunks/index-CA5i_Cgq.js";
+export {
+  W as Utils,
+  Z as evalPro,
+  q as filterInputNum,
+  z as generateHandleInputFn,
+  T as getRouterParams,
+  V as getWebsiteUrl,
+  e as is,
+  r as isArray,
+  t as isBoolean,
+  o as isClient,
+  n as isDate,
+  l as isDef,
+  m as isEdgeBrowser,
+  p as isElement,
+  f as isEmail,
+  u as isEmpty,
+  g as isFunction,
+  b as isHtmlStr,
+  d as isInMobileBrowser,
+  x as isIp,
+  U as isMap,
+  w as isNull,
+  D as isNullAndUnDef,
+  N as isNullOrUnDef,
+  E as isNumber,
+  I as isObject,
+  P as isPromise,
+  h as isPromiseLink,
+  y as isRegExp,
+  B as isServer,
+  S as isString,
+  c as isUnDef,
+  v as isUrl,
+  A as isValidPhoneNumber,
+  H as isWindow,
+  O as isZhLang,
+  k as propTypes,
+  G as renderHtmlStr,
+  F as timeZoneOptions,
+  M as withInstall
+};

package/dist/utils/is.js

@@ -0,0 +1,33 @@
+import { i as a, n as e, l as r, v as n, d as l, a as o, C as t, s as m, y as u, o as f, k as p, D, A as b, x as d, t as g, e as E, f as N, g as w, h as B, c as U, p as c, q as h, m as x, u as y, j as A, b as P, w as S, z as j, r as k, B as v } from "../chunks/is-bvgc5qxU.js";
+export {
+  a as is,
+  e as isArray,
+  r as isBoolean,
+  n as isClient,
+  l as isDate,
+  o as isDef,
+  t as isEdgeBrowser,
+  m as isElement,
+  u as isEmail,
+  f as isEmpty,
+  p as isFunction,
+  D as isHtmlStr,
+  b as isInMobileBrowser,
+  d as isIp,
+  g as isMap,
+  E as isNull,
+  N as isNullAndUnDef,
+  w as isNullOrUnDef,
+  B as isNumber,
+  U as isObject,
+  c as isPromise,
+  h as isPromiseLink,
+  x as isRegExp,
+  y as isServer,
+  A as isString,
+  P as isUnDef,
+  S as isUrl,
+  j as isValidPhoneNumber,
+  k as isWindow,
+  v as isZhLang
+};

package/dist/utils/timeZone.js

@@ -0,0 +1,4 @@
+import { t as e } from "../chunks/timeZone-CYGfhbdm.js";
+export {
+  e as timeZoneOptions
+};

package/dist/utils/vuePropTypes.js

@@ -0,0 +1,6 @@
+import "vue-types";
+import { V as a, p as e } from "../chunks/vuePropTypes-zy5Iwonj.js";
+export {
+  a as default,
+  e as propTypes
+};

package/dist/utils/withInstall.js

@@ -0,0 +1,4 @@
+import { w as l } from "../chunks/withInstall-b5j1glXj.js";
+export {
+  l as withInstall
+};

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "jk-vue-comps",
+  "version": "0.1.0",
+  "description": "jk-vue-comps",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/types/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./components": {
+      "import": "./dist/components/index.js",
+      "require": "./dist/components/index.js"
+    },
+    "./components/GoogleAuth": {
+      "import": "./dist/components/GoogleAuth.js",
+      "require": "./dist/components/GoogleAuth.js"
+    },
+    "./components/TelegramAuth": {
+      "import": "./dist/components/TelegramAuth.js",
+      "require": "./dist/components/TelegramAuth.js"
+    },
+    "./utils": {
+      "import": "./dist/utils/index.js",
+      "require": "./dist/utils/index.js"
+    },
+    "./utils/is": {
+      "import": "./dist/utils/is.js",
+      "require": "./dist/utils/is.js"
+    },
+    "./utils/vuePropTypes": {
+      "import": "./dist/utils/vuePropTypes.js",
+      "require": "./dist/utils/vuePropTypes.js"
+    },
+    "./utils/timeZone": {
+      "import": "./dist/utils/timeZone.js",
+      "require": "./dist/utils/timeZone.js"
+    },
+    "./utils/withInstall": {
+      "import": "./dist/utils/withInstall.js",
+      "require": "./dist/utils/withInstall.js"
+    },
+    "./types": {
+      "import": "./dist/types/index.d.ts",
+      "require": "./dist/types/index.d.ts"
+    }
+  },
+  "keywords": [
+    "vite5",
+    "vue3",
+    "tsx",
+    "JK",
+    "TelegramAuth",
+    "GoogleAuth"
+  ],
+  "scripts": {
+    "dev": "vite",
+    "build": "vue-tsc && vite build",
+    "preview": "vite preview",
+    "format": "prettier --write .",
+    "lint": "eslint --ext .js,.ts,.tsx,.vue src",
+    "lint-fix": "eslint --fix --ext .js,.ts,.tsx,.vue src"
+  },
+  "devDependencies": {
+    "@rollup/plugin-typescript": "^11.1.6",
+    "@types/node": "^20.14.2",
+    "@typescript-eslint/eslint-plugin": "^7.12.0",
+    "@typescript-eslint/parser": "^7.12.0",
+    "@vitejs/plugin-vue": "^5.0.4",
+    "@vitejs/plugin-vue-jsx": "^3.1.0",
+    "eslint": "^8.56.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-vue": "^9.20.0",
+    "prettier": "^3.1.1",
+    "tslib": "^2.6.2",
+    "typescript": "^5.2.2",
+    "vite": "^5.2.0",
+    "vue": "^3.4.21",
+    "vue-tsc": "^2.0.6",
+    "vue-types": "^5.1.2"
+  }
+}