@m5kdev/frontend 0.8.2 → 0.8.4

package/dist/src/modules/auth/auth.lib.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.lib.d.mts","names":[],"sources":["../../../../src/modules/auth/auth.lib.ts"],"mappings":";;;;;cAgDa,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA9BC,kBAAA;IAAA;;;;;;;;;;;;;;;6BAAA,kBAAA;IAAA;;;;;;;;;;;;;;6BAAA,kBAAA;IAAA;;;;;;;;;;6BAAA,kBAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA+B6xB,kBAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAA+wG,qBAAA,CAAA,WAAA;;;;;;;;;;;;;;;;;YAAx5D,YAAA;;;eAA2F,WAAA,IAAA,WAAA;;;;;eAA+U,eAAA;kBAA+C,kBAAA;;;WAAwG,WAAA;eAAwC,eAAA;;qBAAqF,cAAA;cAAyC,WAAA;gBAAgD,QAAA,EAAhD,qBAAA,CAAgD,eAAA,KAAA,OAAA;;;;;qBAAA,qBAAA,CAAA,UAAA;;;;;;;;;;;;;;;;;;;;kCAA27B,YAAA;;cAAA,qBAAA,CAAmG,gBAAA,UAAA,IAAA,UAAA,IAAA;kBAAA,qBAAA,CAAmG,gBAAA;;;;;uBAAuM,IAAA"}

package/dist/src/modules/auth/auth.lib.mjs

@@ -0,0 +1,38 @@
+import { adminClient, inferAdditionalFields, lastLoginMethodClient, organizationClient } from "better-auth/client/plugins";
+import { createAuthClient } from "better-auth/react";
+const authClient = createAuthClient({
+	baseURL: import.meta.env.VITE_SERVER_URL,
+	plugins: [
+		lastLoginMethodClient(),
+		organizationClient({ teams: { enabled: true } }),
+		adminClient(),
+		inferAdditionalFields({
+			user: {
+				onboarding: {
+					type: "number",
+					required: false
+				},
+				preferences: {
+					type: "string",
+					required: false
+				},
+				flags: {
+					type: "string",
+					required: false
+				},
+				stripeCustomerId: {
+					type: "string",
+					required: false
+				}
+			},
+			teamMembers: { role: {
+				type: "string",
+				required: true
+			} }
+		})
+	]
+});
+//#endregion
+export { authClient };
+
+//# sourceMappingURL=auth.lib.mjs.map

package/dist/src/modules/auth/auth.lib.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.lib.mjs","names":[],"sources":["../../../../src/modules/auth/auth.lib.ts"],"sourcesContent":["import type { ClientOptions } from \"better-auth\";\r\nimport {\r\n  adminClient,\r\n  inferAdditionalFields,\r\n  lastLoginMethodClient,\r\n  organizationClient,\r\n} from \"better-auth/client/plugins\";\r\nimport { createAuthClient } from \"better-auth/react\";\r\n\r\nconst options = {\r\n  baseURL: import.meta.env.VITE_SERVER_URL,\r\n  plugins: [\r\n    lastLoginMethodClient(),\r\n    organizationClient({\r\n      teams: {\r\n        enabled: true,\r\n      },\r\n    }),\r\n    adminClient(),\r\n    inferAdditionalFields({\r\n      user: {\r\n        onboarding: {\r\n          type: \"number\",\r\n          required: false,\r\n        },\r\n        preferences: {\r\n          type: \"string\",\r\n          required: false,\r\n        },\r\n        flags: {\r\n          type: \"string\",\r\n          required: false,\r\n        },\r\n        stripeCustomerId: {\r\n          type: \"string\",\r\n          required: false,\r\n        },\r\n      },\r\n      teamMembers: {\r\n        role: {\r\n          type: \"string\",\r\n          required: true,\r\n        },\r\n      },\r\n    }),\r\n  ],\r\n} satisfies ClientOptions;\r\n\r\nexport const authClient = createAuthClient(options);\r\n"],"mappings":";;AAgDA,MAAa,aAAa,iBAvCV;CACd,SAAS,OAAO,KAAK,IAAI;CACzB,SAAS;EACP,uBAAuB;EACvB,mBAAmB,EACjB,OAAO,EACL,SAAS,MACV,EACF,CAAC;EACF,aAAa;EACb,sBAAsB;GACpB,MAAM;IACJ,YAAY;KACV,MAAM;KACN,UAAU;KACX;IACD,aAAa;KACX,MAAM;KACN,UAAU;KACX;IACD,OAAO;KACL,MAAM;KACN,UAAU;KACX;IACD,kBAAkB;KAChB,MAAM;KACN,UAAU;KACX;IACF;GACD,aAAa,EACX,MAAM;IACJ,MAAM;IACN,UAAU;IACX,EACF;GACF,CAAC;EACH;CACF,CAEkD"}

package/dist/src/modules/auth/components/AuthProvider.d.mts

@@ -0,0 +1,24 @@
+import { authClient } from "../auth.lib.mjs";
+import * as _$react from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/modules/auth/components/AuthProvider.d.ts
+type Session = ReturnType<typeof authClient.useSession>["data"];
+declare const authProviderContext: _$react.Context<{
+  isLoading: boolean;
+  data: Session | null;
+  signOut: () => void;
+  registerSession: (onSuccess: () => void) => void;
+}>;
+declare function AuthProvider({
+  children,
+  loader,
+  onSession
+}: {
+  children: React.ReactNode;
+  loader?: React.ReactNode;
+  onSession?: (session: Session | null) => void;
+}): string | number | bigint | true | Iterable<_$react.ReactNode> | Promise<string | number | bigint | boolean | _$react.ReactPortal | _$react.ReactElement<unknown, string | _$react.JSXElementConstructor<any>> | Iterable<_$react.ReactNode> | null | undefined> | _$react_jsx_runtime0.JSX.Element;
+//#endregion
+export { AuthProvider, authProviderContext };
+//# sourceMappingURL=AuthProvider.d.mts.map

package/dist/src/modules/auth/components/AuthProvider.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthProvider.d.mts","names":[],"sources":["../../../../../src/modules/auth/components/AuthProvider.tsx"],"mappings":";;;;;KAIK,OAAA,GAAU,UAAA,QAAkB,UAAA,CAAW,UAAA;AAAA,cAO/B,mBAAA,EAEE,OAAA,CAFiB,OAAA;;QAExB,OAAA;;oBAEY,SAAA;AAAA;AAAA,iBAQJ,YAAA,CAAA;EACd,QAAA;EACA,MAAA;EACA;AAAA;EAEA,QAAA,EAAU,KAAA,CAAM,SAAA;EAChB,MAAA,GAAS,KAAA,CAAM,SAAA;EACf,SAAA,IAAa,OAAA,EAAS,OAAA;AAAA,sCACvB,QAAA,CAD8B,OAAA,CAC9B,SAAA,IAAA,OAAA,sCAAA,OAAA,CAAA,WAAA,GAAA,OAAA,CAAA,YAAA,mBAAA,OAAA,CAAA,qBAAA,SAAA,QAAA,CAAA,OAAA,CAAA,SAAA,wBAAA,oBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/src/modules/auth/components/AuthProvider.mjs

@@ -0,0 +1,75 @@
+import { authClient } from "../auth.lib.mjs";
+import { usePostHog } from "posthog-js/react/dist/esm/index.js";
+import { createContext, useCallback, useEffect, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/modules/auth/components/AuthProvider.tsx
+function isImpersonatedSession(session) {
+	const sessionData = session?.session;
+	return Boolean(sessionData?.impersonatedBy);
+}
+const authProviderContext = createContext({
+	isLoading: true,
+	data: null,
+	signOut: () => {},
+	registerSession: () => {}
+});
+function AuthProvider({ children, loader, onSession }) {
+	const posthog = usePostHog();
+	const [isLoading, setIsLoading] = useState(true);
+	const [session, setSession] = useState(null);
+	const registerSession = useCallback((onSuccess) => {
+		authClient.getSession().then(({ data: nextSession }) => {
+			setIsLoading(false);
+			setSession(nextSession);
+			onSession?.(nextSession);
+			if (isImpersonatedSession(nextSession)) {
+				posthog.opt_out_capturing();
+				posthog.reset();
+				onSuccess?.();
+				return;
+			}
+			posthog.opt_in_capturing();
+			if (nextSession?.user) posthog.identify(nextSession.user.id, {
+				email: nextSession.user.email,
+				name: nextSession.user.name,
+				createdAt: nextSession.user.createdAt,
+				updatedAt: nextSession.user.updatedAt,
+				role: nextSession.user.role,
+				image: nextSession.user.image,
+				preferences: nextSession.user.preferences,
+				onboarding: nextSession.user.onboarding,
+				flags: nextSession.user.flags
+			});
+			else posthog.reset();
+			onSuccess?.();
+		}).catch((error) => {
+			console.error("Failed to get session:", error);
+			setIsLoading(false);
+			setSession(null);
+		});
+	}, [onSession, posthog]);
+	useEffect(() => {
+		registerSession();
+	}, []);
+	const signOut = useCallback(() => {
+		authClient.signOut().then(() => {
+			posthog.reset();
+			posthog.opt_in_capturing();
+			setSession(null);
+		});
+	}, [posthog]);
+	if (isLoading) return loader ? loader : "Loading...";
+	return /* @__PURE__ */ jsx(authProviderContext.Provider, {
+		value: {
+			isLoading,
+			data: session,
+			signOut,
+			registerSession
+		},
+		children
+	});
+}
+//#endregion
+export { AuthProvider, authProviderContext };
+
+//# sourceMappingURL=AuthProvider.mjs.map

package/dist/src/modules/auth/components/AuthProvider.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthProvider.mjs","names":[],"sources":["../../../../../src/modules/auth/components/AuthProvider.tsx"],"sourcesContent":["import { usePostHog } from \"posthog-js/react\";\r\nimport { createContext, useCallback, useEffect, useState } from \"react\";\r\nimport { authClient } from \"../auth.lib\";\r\n\r\ntype Session = ReturnType<typeof authClient.useSession>[\"data\"];\r\n\r\nfunction isImpersonatedSession(session: Session | null): boolean {\r\n  const sessionData = session?.session as { impersonatedBy?: string | null } | undefined;\r\n  return Boolean(sessionData?.impersonatedBy);\r\n}\r\n\r\nexport const authProviderContext = createContext<{\r\n  isLoading: boolean;\r\n  data: Session | null;\r\n  signOut: () => void;\r\n  registerSession: (onSuccess: () => void) => void;\r\n}>({\r\n  isLoading: true,\r\n  data: null,\r\n  signOut: () => {},\r\n  registerSession: () => {},\r\n});\r\n\r\nexport function AuthProvider({\r\n  children,\r\n  loader,\r\n  onSession,\r\n}: {\r\n  children: React.ReactNode;\r\n  loader?: React.ReactNode;\r\n  onSession?: (session: Session | null) => void;\r\n}) {\r\n  const posthog = usePostHog();\r\n  const [isLoading, setIsLoading] = useState(true);\r\n  const [session, setSession] = useState<Session | null>(null);\r\n\r\n  const registerSession = useCallback(\r\n    (onSuccess?: () => void) => {\r\n      authClient\r\n        .getSession()\r\n        .then(({ data: nextSession }) => {\r\n          setIsLoading(false);\r\n          setSession(nextSession);\r\n          onSession?.(nextSession);\r\n\r\n          if (isImpersonatedSession(nextSession)) {\r\n            posthog.opt_out_capturing();\r\n            posthog.reset();\r\n            onSuccess?.();\r\n            return;\r\n          }\r\n\r\n          posthog.opt_in_capturing();\r\n\r\n          if (nextSession?.user) {\r\n            posthog.identify(nextSession.user.id, {\r\n              email: nextSession.user.email,\r\n              name: nextSession.user.name,\r\n              createdAt: nextSession.user.createdAt,\r\n              updatedAt: nextSession.user.updatedAt,\r\n              role: nextSession.user.role,\r\n              image: nextSession.user.image,\r\n              preferences: nextSession.user.preferences,\r\n              onboarding: nextSession.user.onboarding,\r\n              flags: nextSession.user.flags,\r\n            });\r\n          } else {\r\n            posthog.reset();\r\n          }\r\n\r\n          onSuccess?.();\r\n        })\r\n        .catch((error) => {\r\n          console.error(\"Failed to get session:\", error);\r\n          setIsLoading(false);\r\n          setSession(null);\r\n        });\r\n    },\r\n    [onSession, posthog]\r\n  );\r\n\r\n  // biome-ignore lint/correctness/useExhaustiveDependencies(registerSession): registerSession is a callback\r\n  useEffect(() => {\r\n    registerSession();\r\n  }, []);\r\n\r\n  const signOut = useCallback(() => {\r\n    authClient.signOut().then(() => {\r\n      posthog.reset();\r\n      posthog.opt_in_capturing();\r\n      setSession(null);\r\n    });\r\n  }, [posthog]);\r\n\r\n  // Show loading screen while checking authentication status\r\n  if (isLoading) {\r\n    return loader ? loader : \"Loading...\";\r\n  }\r\n\r\n  return (\r\n    <authProviderContext.Provider value={{ isLoading, data: session, signOut, registerSession }}>\r\n      {children}\r\n    </authProviderContext.Provider>\r\n  );\r\n}\r\n"],"mappings":";;;;;AAMA,SAAS,sBAAsB,SAAkC;CAC/D,MAAM,cAAc,SAAS;AAC7B,QAAO,QAAQ,aAAa,eAAe;;AAG7C,MAAa,sBAAsB,cAKhC;CACD,WAAW;CACX,MAAM;CACN,eAAe;CACf,uBAAuB;CACxB,CAAC;AAEF,SAAgB,aAAa,EAC3B,UACA,QACA,aAKC;CACD,MAAM,UAAU,YAAY;CAC5B,MAAM,CAAC,WAAW,gBAAgB,SAAS,KAAK;CAChD,MAAM,CAAC,SAAS,cAAc,SAAyB,KAAK;CAE5D,MAAM,kBAAkB,aACrB,cAA2B;AAC1B,aACG,YAAY,CACZ,MAAM,EAAE,MAAM,kBAAkB;AAC/B,gBAAa,MAAM;AACnB,cAAW,YAAY;AACvB,eAAY,YAAY;AAExB,OAAI,sBAAsB,YAAY,EAAE;AACtC,YAAQ,mBAAmB;AAC3B,YAAQ,OAAO;AACf,iBAAa;AACb;;AAGF,WAAQ,kBAAkB;AAE1B,OAAI,aAAa,KACf,SAAQ,SAAS,YAAY,KAAK,IAAI;IACpC,OAAO,YAAY,KAAK;IACxB,MAAM,YAAY,KAAK;IACvB,WAAW,YAAY,KAAK;IAC5B,WAAW,YAAY,KAAK;IAC5B,MAAM,YAAY,KAAK;IACvB,OAAO,YAAY,KAAK;IACxB,aAAa,YAAY,KAAK;IAC9B,YAAY,YAAY,KAAK;IAC7B,OAAO,YAAY,KAAK;IACzB,CAAC;OAEF,SAAQ,OAAO;AAGjB,gBAAa;IACb,CACD,OAAO,UAAU;AAChB,WAAQ,MAAM,0BAA0B,MAAM;AAC9C,gBAAa,MAAM;AACnB,cAAW,KAAK;IAChB;IAEN,CAAC,WAAW,QAAQ,CACrB;AAGD,iBAAgB;AACd,mBAAiB;IAChB,EAAE,CAAC;CAEN,MAAM,UAAU,kBAAkB;AAChC,aAAW,SAAS,CAAC,WAAW;AAC9B,WAAQ,OAAO;AACf,WAAQ,kBAAkB;AAC1B,cAAW,KAAK;IAChB;IACD,CAAC,QAAQ,CAAC;AAGb,KAAI,UACF,QAAO,SAAS,SAAS;AAG3B,QACE,oBAAC,oBAAoB,UAArB;EAA8B,OAAO;GAAE;GAAW,MAAM;GAAS;GAAS;GAAiB;EACxF;EAC4B,CAAA"}

package/dist/src/modules/auth/hooks/useAuth.d.mts

@@ -0,0 +1,9 @@
+import * as _$_tanstack_react_query0 from "@tanstack/react-query";
+import { AnyUseMutationOptions } from "@tanstack/react-query";
+
+//#region src/modules/auth/hooks/useAuth.d.ts
+declare function useUpdateUser(options: AnyUseMutationOptions): _$_tanstack_react_query0.UseMutationResult<any, any, any, any>;
+declare function useUpdateUserPreferences<T extends Record<string, any>>(options: AnyUseMutationOptions): _$_tanstack_react_query0.UseMutationResult<any, any, any, any>;
+//#endregion
+export { useUpdateUser, useUpdateUserPreferences };
+//# sourceMappingURL=useAuth.d.mts.map

package/dist/src/modules/auth/hooks/useAuth.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuth.d.mts","names":[],"sources":["../../../../../src/modules/auth/hooks/useAuth.ts"],"mappings":";;;;iBAGgB,aAAA,CAAc,OAAA,EAAS,qBAAA,GAAqB,wBAAA,CAAA,iBAAA;AAAA,iBAQ5C,wBAAA,WAAmC,MAAA,cAAA,CACjD,OAAA,EAAS,qBAAA,GAAqB,wBAAA,CAAA,iBAAA"}

package/dist/src/modules/auth/hooks/useAuth.mjs

@@ -0,0 +1,19 @@
+import { authClient } from "../auth.lib.mjs";
+import { useMutation } from "@tanstack/react-query";
+//#region src/modules/auth/hooks/useAuth.ts
+function useUpdateUser(options) {
+	return useMutation({
+		mutationFn: (...args) => authClient.updateUser(...args),
+		...options
+	});
+}
+function useUpdateUserPreferences(options) {
+	return useMutation({
+		mutationFn: (preferences) => authClient.updateUser({ preferences: JSON.stringify(preferences) }),
+		...options
+	});
+}
+//#endregion
+export { useUpdateUser, useUpdateUserPreferences };
+
+//# sourceMappingURL=useAuth.mjs.map

package/dist/src/modules/auth/hooks/useAuth.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuth.mjs","names":[],"sources":["../../../../../src/modules/auth/hooks/useAuth.ts"],"sourcesContent":["import { type AnyUseMutationOptions, useMutation } from \"@tanstack/react-query\";\r\nimport { authClient } from \"../auth.lib\";\r\n\r\nexport function useUpdateUser(options: AnyUseMutationOptions) {\r\n  return useMutation({\r\n    mutationFn: (...args: Parameters<typeof authClient.updateUser>) =>\r\n      authClient.updateUser(...args),\r\n    ...options,\r\n  });\r\n}\r\n\r\nexport function useUpdateUserPreferences<T extends Record<string, any>>(\r\n  options: AnyUseMutationOptions\r\n) {\r\n  return useMutation({\r\n    mutationFn: (preferences: T) =>\r\n      authClient.updateUser({ preferences: JSON.stringify(preferences) as string }),\r\n    ...options,\r\n  });\r\n}\r\n"],"mappings":";;;AAGA,SAAgB,cAAc,SAAgC;AAC5D,QAAO,YAAY;EACjB,aAAa,GAAG,SACd,WAAW,WAAW,GAAG,KAAK;EAChC,GAAG;EACJ,CAAC;;AAGJ,SAAgB,yBACd,SACA;AACA,QAAO,YAAY;EACjB,aAAa,gBACX,WAAW,WAAW,EAAE,aAAa,KAAK,UAAU,YAAY,EAAY,CAAC;EAC/E,GAAG;EACJ,CAAC"}

package/dist/src/modules/auth/hooks/useAuthAdmin.d.mts

@@ -0,0 +1,26 @@
+import { authClient } from "../auth.lib.mjs";
+import * as _$_tanstack_react_query0 from "@tanstack/react-query";
+import { AnyUseMutationOptions } from "@tanstack/react-query";
+import * as _$better_auth_plugins0 from "better-auth/plugins";
+
+//#region src/modules/auth/hooks/useAuthAdmin.d.ts
+type ListUsersArgs = Parameters<typeof authClient.admin.listUsers>;
+declare function useInvalidateListUsers(...args: ListUsersArgs): () => Promise<void>;
+declare function useListUsers(...args: ListUsersArgs): _$_tanstack_react_query0.UseQueryResult<NonNullable<{
+  users: _$better_auth_plugins0.UserWithRole[];
+  total: number;
+  limit: number | undefined;
+  offset: number | undefined;
+} | {
+  users: never[];
+  total: number;
+}>, Error>;
+declare function useRemoveUser(options: AnyUseMutationOptions): _$_tanstack_react_query0.UseMutationResult<any, any, any, any>;
+declare function useUpdateUser(options: AnyUseMutationOptions): _$_tanstack_react_query0.UseMutationResult<any, any, any, any>;
+declare function useBanUser(options: AnyUseMutationOptions): _$_tanstack_react_query0.UseMutationResult<any, any, any, any>;
+declare function useUnbanUser(options: AnyUseMutationOptions): _$_tanstack_react_query0.UseMutationResult<any, any, any, any>;
+declare function useImpersonateUser(options: AnyUseMutationOptions): _$_tanstack_react_query0.UseMutationResult<any, any, any, any>;
+declare function useStopImpersonating(options: AnyUseMutationOptions): _$_tanstack_react_query0.UseMutationResult<any, any, any, any>;
+//#endregion
+export { useBanUser, useImpersonateUser, useInvalidateListUsers, useListUsers, useRemoveUser, useStopImpersonating, useUnbanUser, useUpdateUser };
+//# sourceMappingURL=useAuthAdmin.d.mts.map

package/dist/src/modules/auth/hooks/useAuthAdmin.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuthAdmin.d.mts","names":[],"sources":["../../../../../src/modules/auth/hooks/useAuthAdmin.ts"],"mappings":";;;;;;KAeK,aAAA,GAAgB,UAAA,QAAkB,UAAA,CAAW,KAAA,CAAM,SAAA;AAAA,iBA4ExC,sBAAA,CAAA,GAA0B,IAAA,EAAM,aAAA,SAAa,OAAA;AAAA,iBAuC7C,YAAA,CAAA,GAAgB,IAAA,EAAM,aAAA,4BAAa,cAAA,CAAA,WAAA;SAAA,sBAAA,CAAA,YAAA;;;;;;;;iBAYnC,aAAA,CAAc,OAAA,EAAS,qBAAA,GAAqB,wBAAA,CAAA,iBAAA;AAAA,iBAQ5C,aAAA,CAAc,OAAA,EAAS,qBAAA,GAAqB,wBAAA,CAAA,iBAAA;AAAA,iBAQ5C,UAAA,CAAW,OAAA,EAAS,qBAAA,GAAqB,wBAAA,CAAA,iBAAA;AAAA,iBAQzC,YAAA,CAAa,OAAA,EAAS,qBAAA,GAAqB,wBAAA,CAAA,iBAAA;AAAA,iBAQ3C,kBAAA,CAAmB,OAAA,EAAS,qBAAA,GAAqB,wBAAA,CAAA,iBAAA;AAAA,iBAQjD,oBAAA,CAAqB,OAAA,EAAS,qBAAA,GAAqB,wBAAA,CAAA,iBAAA"}

package/dist/src/modules/auth/hooks/useAuthAdmin.mjs

@@ -0,0 +1,58 @@
+import { authClient } from "../auth.lib.mjs";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+//#region src/modules/auth/hooks/useAuthAdmin.ts
+function useInvalidateListUsers(...args) {
+	const queryClient = useQueryClient();
+	return () => queryClient.invalidateQueries({ queryKey: ["auth-admin-list-users", ...args] });
+}
+function useListUsers(...args) {
+	return useQuery({
+		queryKey: ["auth-admin-list-users", ...args],
+		queryFn: async ({ queryKey }) => {
+			const listUserArgs = queryKey.slice(1);
+			const { data, error } = await authClient.admin.listUsers(...listUserArgs);
+			if (error) return Promise.reject(error);
+			return data;
+		}
+	});
+}
+function useRemoveUser(options) {
+	return useMutation({
+		mutationFn: (...args) => authClient.admin.removeUser(...args),
+		...options
+	});
+}
+function useUpdateUser(options) {
+	return useMutation({
+		mutationFn: (...args) => authClient.admin.updateUser(...args),
+		...options
+	});
+}
+function useBanUser(options) {
+	return useMutation({
+		mutationFn: (...args) => authClient.admin.banUser(...args),
+		...options
+	});
+}
+function useUnbanUser(options) {
+	return useMutation({
+		mutationFn: (...args) => authClient.admin.unbanUser(...args),
+		...options
+	});
+}
+function useImpersonateUser(options) {
+	return useMutation({
+		mutationFn: (...args) => authClient.admin.impersonateUser(...args),
+		...options
+	});
+}
+function useStopImpersonating(options) {
+	return useMutation({
+		mutationFn: () => authClient.admin.stopImpersonating(),
+		...options
+	});
+}
+//#endregion
+export { useBanUser, useImpersonateUser, useInvalidateListUsers, useListUsers, useRemoveUser, useStopImpersonating, useUnbanUser, useUpdateUser };
+
+//# sourceMappingURL=useAuthAdmin.mjs.map

package/dist/src/modules/auth/hooks/useAuthAdmin.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuthAdmin.mjs","names":[],"sources":["../../../../../src/modules/auth/hooks/useAuthAdmin.ts"],"sourcesContent":["import {\r\n  type AnyUseMutationOptions,\r\n  useMutation,\r\n  useQuery,\r\n  useQueryClient,\r\n} from \"@tanstack/react-query\";\r\nimport { authClient } from \"../auth.lib\";\r\n\r\n// import type { QueryFilter, QueryInput } from \"@m5kdev/commons/modules/schemas/query.schema\";\r\n// import type {\r\n//   FilterMethod,\r\n//   FilterMethodName,\r\n//   FilterMethods,\r\n// } from \"@m5kdev/commons/modules/table/filter.types\";\r\n\r\ntype ListUsersArgs = Parameters<typeof authClient.admin.listUsers>;\r\n\r\n/*\r\ntype ListUsersParams = Parameters<typeof authClient.admin.listUsers>;\r\ntype ListUsersArgs = Record<string, unknown>;\r\n\r\ntype FilterOperator = \"eq\" | \"ne\" | \"lt\" | \"lte\" | \"gt\" | \"gte\";\r\n\r\ntype BetterAuthFilterParams = {\r\n  filterField: string;\r\n  filterValue: string | number | boolean;\r\n  filterOperator: FilterOperator;\r\n};\r\n\r\nexport const authFilterMethods: FilterMethods = {\r\n  string: [{ value: \"equals\", label: \"Equals\", component: \"text\" }],\r\n  number: [\r\n    { value: \"equals\", label: \"Equals\", component: \"number\" },\r\n    { value: \"greater_than\", label: \"Greater Than\", component: \"number\" },\r\n    { value: \"less_than\", label: \"Less Than\", component: \"number\" },\r\n  ],\r\n  date: [\r\n    { value: \"on\", label: \"On\", component: \"date\" },\r\n    { value: \"before\", label: \"Before\", component: \"date\" },\r\n    { value: \"after\", label: \"After\", component: \"date\" },\r\n  ],\r\n  boolean: [{ value: \"equals\", label: \"Equals\", component: \"radio\" }],\r\n  enum: [{ value: \"equals\", label: \"Equals\", component: \"select\" }],\r\n};\r\n\r\nconst baseMethodOperatorMap: Partial<Record<FilterMethodName, FilterOperator>> = {\r\n  equals: \"eq\",\r\n  greater_than: \"gt\",\r\n  less_than: \"lt\",\r\n  before: \"lte\",\r\n  after: \"gte\",\r\n  on: \"eq\",\r\n};\r\n\r\nconst getAllowedMethods = (): Record<FilterMethodName, FilterOperator> => {\r\n  const operatorMap: Partial<Record<FilterMethodName, FilterOperator>> = {};\r\n  Object.values(authFilterMethods).forEach((methodsForType) => {\r\n    methodsForType.forEach((method: FilterMethod) => {\r\n      const operator = baseMethodOperatorMap[method.value];\r\n      if (operator) {\r\n        operatorMap[method.value] = operator;\r\n      }\r\n    });\r\n  });\r\n  return operatorMap as Record<FilterMethodName, FilterOperator>;\r\n};\r\n\r\nconst filterMethodToOperatorMap = getAllowedMethods();\r\n\r\nconst mapFilterToBetterAuth = (filter?: QueryFilter): Partial<BetterAuthFilterParams> => {\r\n  if (!filter) return {};\r\n  if (!filter.type) return {};\r\n  const allowedMethodsForType = authFilterMethods[filter.type]?.map((method) => method.value) ?? [];\r\n  if (!allowedMethodsForType.includes(filter.method)) return {};\r\n  const operator = filterMethodToOperatorMap[filter.method];\r\n  if (!operator) return {};\r\n  const { columnId, value, type } = filter;\r\n  if (value === undefined || value === null) return {};\r\n  if (type === \"boolean\" && typeof value === \"boolean\" && operator === \"eq\") {\r\n    return { filterField: columnId, filterValue: value, filterOperator: operator };\r\n  }\r\n  if (type === \"number\" && typeof value === \"number\") {\r\n    return { filterField: columnId, filterValue: value, filterOperator: operator };\r\n  }\r\n  if ((type === \"string\" || type === \"enum\" || type === \"date\") && typeof value === \"string\") {\r\n    return { filterField: columnId, filterValue: value, filterOperator: operator };\r\n  }\r\n  return {};\r\n};\r\n*/\r\n\r\nexport function useInvalidateListUsers(...args: ListUsersArgs) {\r\n  const queryClient = useQueryClient();\r\n  return () => queryClient.invalidateQueries({ queryKey: [\"auth-admin-list-users\", ...args] });\r\n}\r\n\r\n/*\r\nexport function getListUsers(input: ListUsersArgs): any {\r\n  const {\r\n    filters,\r\n    page,\r\n    limit,\r\n    sort,\r\n    order,\r\n    ...listUsersParams\r\n  } = input as ListUsersArgs & QueryInput;\r\n  const filterParams = mapFilterToBetterAuth(filters?.[0]);\r\n  const sortDirection: \"asc\" | \"desc\" = order === \"asc\" ? \"asc\" : \"desc\";\r\n  const queryPayload = {\r\n    ...listUsersParams,\r\n    limit,\r\n    sortBy: sort,\r\n    sortDirection,\r\n    offset: (page - 1) * limit,\r\n    ...filterParams,\r\n  };\r\n\r\n  return {\r\n    queryKey: [\"auth-admin-list-users\", input],\r\n    queryFn: async () => {\r\n      const { data, error } = await authClient.admin.listUsers({\r\n        query: queryPayload,\r\n      });\r\n      if (error) return Promise.reject(error);\r\n      return data;\r\n    },\r\n  };\r\n}\r\n*/\r\n\r\nexport function useListUsers(...args: ListUsersArgs) {\r\n  return useQuery({\r\n    queryKey: [\"auth-admin-list-users\", ...args],\r\n    queryFn: async ({ queryKey }) => {\r\n      const listUserArgs = queryKey.slice(1) as ListUsersArgs;\r\n      const { data, error } = await authClient.admin.listUsers(...listUserArgs);\r\n      if (error) return Promise.reject(error);\r\n      return data;\r\n    },\r\n  });\r\n}\r\n\r\nexport function useRemoveUser(options: AnyUseMutationOptions) {\r\n  return useMutation({\r\n    mutationFn: (...args: Parameters<typeof authClient.admin.removeUser>) =>\r\n      authClient.admin.removeUser(...args),\r\n    ...options,\r\n  });\r\n}\r\n\r\nexport function useUpdateUser(options: AnyUseMutationOptions) {\r\n  return useMutation({\r\n    mutationFn: (...args: Parameters<typeof authClient.admin.updateUser>) =>\r\n      authClient.admin.updateUser(...args),\r\n    ...options,\r\n  });\r\n}\r\n\r\nexport function useBanUser(options: AnyUseMutationOptions) {\r\n  return useMutation({\r\n    mutationFn: (...args: Parameters<typeof authClient.admin.banUser>) =>\r\n      authClient.admin.banUser(...args),\r\n    ...options,\r\n  });\r\n}\r\n\r\nexport function useUnbanUser(options: AnyUseMutationOptions) {\r\n  return useMutation({\r\n    mutationFn: (...args: Parameters<typeof authClient.admin.unbanUser>) =>\r\n      authClient.admin.unbanUser(...args),\r\n    ...options,\r\n  });\r\n}\r\n\r\nexport function useImpersonateUser(options: AnyUseMutationOptions) {\r\n  return useMutation({\r\n    mutationFn: (...args: Parameters<typeof authClient.admin.impersonateUser>) =>\r\n      authClient.admin.impersonateUser(...args),\r\n    ...options,\r\n  });\r\n}\r\n\r\nexport function useStopImpersonating(options: AnyUseMutationOptions) {\r\n  return useMutation({\r\n    mutationFn: () => authClient.admin.stopImpersonating(),\r\n    ...options,\r\n  });\r\n}\r\n"],"mappings":";;;AA2FA,SAAgB,uBAAuB,GAAG,MAAqB;CAC7D,MAAM,cAAc,gBAAgB;AACpC,cAAa,YAAY,kBAAkB,EAAE,UAAU,CAAC,yBAAyB,GAAG,KAAK,EAAE,CAAC;;AAqC9F,SAAgB,aAAa,GAAG,MAAqB;AACnD,QAAO,SAAS;EACd,UAAU,CAAC,yBAAyB,GAAG,KAAK;EAC5C,SAAS,OAAO,EAAE,eAAe;GAC/B,MAAM,eAAe,SAAS,MAAM,EAAE;GACtC,MAAM,EAAE,MAAM,UAAU,MAAM,WAAW,MAAM,UAAU,GAAG,aAAa;AACzE,OAAI,MAAO,QAAO,QAAQ,OAAO,MAAM;AACvC,UAAO;;EAEV,CAAC;;AAGJ,SAAgB,cAAc,SAAgC;AAC5D,QAAO,YAAY;EACjB,aAAa,GAAG,SACd,WAAW,MAAM,WAAW,GAAG,KAAK;EACtC,GAAG;EACJ,CAAC;;AAGJ,SAAgB,cAAc,SAAgC;AAC5D,QAAO,YAAY;EACjB,aAAa,GAAG,SACd,WAAW,MAAM,WAAW,GAAG,KAAK;EACtC,GAAG;EACJ,CAAC;;AAGJ,SAAgB,WAAW,SAAgC;AACzD,QAAO,YAAY;EACjB,aAAa,GAAG,SACd,WAAW,MAAM,QAAQ,GAAG,KAAK;EACnC,GAAG;EACJ,CAAC;;AAGJ,SAAgB,aAAa,SAAgC;AAC3D,QAAO,YAAY;EACjB,aAAa,GAAG,SACd,WAAW,MAAM,UAAU,GAAG,KAAK;EACrC,GAAG;EACJ,CAAC;;AAGJ,SAAgB,mBAAmB,SAAgC;AACjE,QAAO,YAAY;EACjB,aAAa,GAAG,SACd,WAAW,MAAM,gBAAgB,GAAG,KAAK;EAC3C,GAAG;EACJ,CAAC;;AAGJ,SAAgB,qBAAqB,SAAgC;AACnE,QAAO,YAAY;EACjB,kBAAkB,WAAW,MAAM,mBAAmB;EACtD,GAAG;EACJ,CAAC"}

package/dist/src/modules/auth/hooks/useSession.d.mts

@@ -0,0 +1,41 @@
+//#region src/modules/auth/hooks/useSession.d.ts
+declare function useSession(): {
+  isLoading: boolean;
+  data: ({
+    user: {
+      id: string;
+      createdAt: Date;
+      updatedAt: Date;
+      email: string;
+      emailVerified: boolean;
+      name: string;
+      image?: string | null | undefined;
+      banned: boolean | null | undefined;
+      role?: string | null | undefined;
+      banReason?: string | null | undefined;
+      banExpires?: Date | null | undefined;
+      stripeCustomerId?: string | null | undefined;
+      onboarding?: number | null | undefined;
+      preferences?: string | null | undefined;
+      flags?: string | null | undefined;
+    };
+    session: {
+      id: string;
+      createdAt: Date;
+      updatedAt: Date;
+      userId: string;
+      expiresAt: Date;
+      token: string;
+      ipAddress?: string | null | undefined;
+      userAgent?: string | null | undefined;
+      activeOrganizationId?: string | null | undefined;
+      activeTeamId?: string | null | undefined;
+      impersonatedBy?: string | null | undefined;
+    };
+  } | null) | null;
+  signOut: () => void;
+  registerSession: (onSuccess: () => void) => void;
+};
+//#endregion
+export { useSession };
+//# sourceMappingURL=useSession.d.mts.map

package/dist/src/modules/auth/hooks/useSession.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSession.d.mts","names":[],"sources":["../../../../../src/modules/auth/hooks/useSession.ts"],"mappings":";iBAGgB,UAAA,CAAA"}

package/dist/src/modules/auth/hooks/useSession.mjs

@@ -0,0 +1,10 @@
+import { authProviderContext } from "../components/AuthProvider.mjs";
+import { useContext } from "react";
+//#region src/modules/auth/hooks/useSession.ts
+function useSession() {
+	return useContext(authProviderContext);
+}
+//#endregion
+export { useSession };
+
+//# sourceMappingURL=useSession.mjs.map

package/dist/src/modules/auth/hooks/useSession.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSession.mjs","names":[],"sources":["../../../../../src/modules/auth/hooks/useSession.ts"],"sourcesContent":["import { useContext } from \"react\";\r\nimport { authProviderContext } from \"../components/AuthProvider\";\r\n\r\nexport function useSession() {\r\n  return useContext(authProviderContext);\r\n}\r\n"],"mappings":";;;AAGA,SAAgB,aAAa;AAC3B,QAAO,WAAW,oBAAoB"}

package/dist/src/modules/billing/components/BillingProvider.d.mts

@@ -0,0 +1,26 @@
+import { UseBackendTRPC } from "../../../types.mjs";
+import * as _$react from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+import { BillingSchema } from "@m5kdev/commons/modules/billing/billing.schema";
+
+//#region src/modules/billing/components/BillingProvider.d.ts
+declare const billingProviderContext: _$react.Context<{
+  isLoading: boolean;
+  data: BillingSchema | null;
+}>;
+declare function BillingProvider({
+  useTRPC,
+  children,
+  loader,
+  planPage,
+  skipPlanCheck
+}: {
+  useTRPC: UseBackendTRPC;
+  children: React.ReactNode;
+  loader?: React.ReactNode;
+  planPage: React.ReactNode;
+  skipPlanCheck?: boolean;
+}): string | number | bigint | boolean | Iterable<_$react.ReactNode> | Promise<string | number | bigint | boolean | _$react.ReactPortal | _$react.ReactElement<unknown, string | _$react.JSXElementConstructor<any>> | Iterable<_$react.ReactNode> | null | undefined> | _$react_jsx_runtime0.JSX.Element | null | undefined;
+//#endregion
+export { BillingProvider, billingProviderContext };
+//# sourceMappingURL=BillingProvider.d.mts.map

package/dist/src/modules/billing/components/BillingProvider.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BillingProvider.d.mts","names":[],"sources":["../../../../../src/modules/billing/components/BillingProvider.tsx"],"mappings":";;;;;;cAKa,sBAAA,EAEQ,OAAA,CAFc,OAAA;;QAE3B,aAAA;AAAA;AAAA,iBAMQ,eAAA,CAAA;EACd,OAAA;EACA,QAAA;EACA,MAAA;EACA,QAAA;EACA;AAAA;EAEA,OAAA,EAAS,cAAA;EACT,QAAA,EAAU,KAAA,CAAM,SAAA;EAChB,MAAA,GAAS,KAAA,CAAM,SAAA;EACf,QAAA,EAAU,KAAA,CAAM,SAAA;EAChB,aAAA;AAAA,yCACD,QAAA,CAF0B,OAAA,CAE1B,SAAA,IAAA,OAAA,sCAAA,OAAA,CAAA,WAAA,GAAA,OAAA,CAAA,YAAA,mBAAA,OAAA,CAAA,qBAAA,SAAA,QAAA,CAAA,OAAA,CAAA,SAAA,wBAAA,oBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/src/modules/billing/components/BillingProvider.mjs

@@ -0,0 +1,34 @@
+import { createContext } from "react";
+import { jsx } from "react/jsx-runtime";
+import { useQuery } from "@tanstack/react-query";
+//#region src/modules/billing/components/BillingProvider.tsx
+const billingProviderContext = createContext({
+	isLoading: true,
+	data: null
+});
+function BillingProvider({ useTRPC, children, loader, planPage, skipPlanCheck = false }) {
+	const { data: activeSubscription, isLoading } = useQuery(useTRPC().billing.getActiveSubscription.queryOptions(void 0, {
+		staleTime: 1e3 * 60 * 60 * 4,
+		enabled: !skipPlanCheck
+	}));
+	if (skipPlanCheck) return /* @__PURE__ */ jsx(billingProviderContext.Provider, {
+		value: {
+			isLoading: false,
+			data: null
+		},
+		children
+	});
+	if (isLoading) return loader ? loader : "Loading...";
+	if (!activeSubscription) return planPage;
+	return /* @__PURE__ */ jsx(billingProviderContext.Provider, {
+		value: {
+			isLoading,
+			data: activeSubscription ?? null
+		},
+		children
+	});
+}
+//#endregion
+export { BillingProvider, billingProviderContext };
+
+//# sourceMappingURL=BillingProvider.mjs.map

package/dist/src/modules/billing/components/BillingProvider.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BillingProvider.mjs","names":[],"sources":["../../../../../src/modules/billing/components/BillingProvider.tsx"],"sourcesContent":["import type { BillingSchema } from \"@m5kdev/commons/modules/billing/billing.schema\";\r\nimport { useQuery } from \"@tanstack/react-query\";\r\nimport { createContext } from \"react\";\r\nimport type { UseBackendTRPC } from \"../../../types\";\r\n\r\nexport const billingProviderContext = createContext<{\r\n  isLoading: boolean;\r\n  data: BillingSchema | null;\r\n}>({\r\n  isLoading: true,\r\n  data: null,\r\n});\r\n\r\nexport function BillingProvider({\r\n  useTRPC,\r\n  children,\r\n  loader,\r\n  planPage,\r\n  skipPlanCheck = false,\r\n}: {\r\n  useTRPC: UseBackendTRPC;\r\n  children: React.ReactNode;\r\n  loader?: React.ReactNode;\r\n  planPage: React.ReactNode;\r\n  skipPlanCheck?: boolean;\r\n}) {\r\n  const trpc = useTRPC();\r\n\r\n  const { data: activeSubscription, isLoading } = useQuery(\r\n    trpc.billing.getActiveSubscription.queryOptions(undefined, {\r\n      staleTime: 1000 * 60 * 60 * 4, // 4 hours\r\n      enabled: !skipPlanCheck,\r\n    })\r\n  );\r\n\r\n  if (skipPlanCheck) {\r\n    return (\r\n      <billingProviderContext.Provider value={{ isLoading: false, data: null }}>\r\n        {children}\r\n      </billingProviderContext.Provider>\r\n    );\r\n  }\r\n\r\n  // Show loading screen while checking subscription status\r\n  if (isLoading) {\r\n    return loader ? loader : \"Loading...\";\r\n  }\r\n\r\n  if (!activeSubscription) {\r\n    return planPage;\r\n  }\r\n\r\n  return (\r\n    <billingProviderContext.Provider value={{ isLoading, data: activeSubscription ?? null }}>\r\n      {children}\r\n    </billingProviderContext.Provider>\r\n  );\r\n}\r\n"],"mappings":";;;;AAKA,MAAa,yBAAyB,cAGnC;CACD,WAAW;CACX,MAAM;CACP,CAAC;AAEF,SAAgB,gBAAgB,EAC9B,SACA,UACA,QACA,UACA,gBAAgB,SAOf;CAGD,MAAM,EAAE,MAAM,oBAAoB,cAAc,SAFnC,SAAS,CAGf,QAAQ,sBAAsB,aAAa,KAAA,GAAW;EACzD,WAAW,MAAO,KAAK,KAAK;EAC5B,SAAS,CAAC;EACX,CAAC,CACH;AAED,KAAI,cACF,QACE,oBAAC,uBAAuB,UAAxB;EAAiC,OAAO;GAAE,WAAW;GAAO,MAAM;GAAM;EACrE;EAC+B,CAAA;AAKtC,KAAI,UACF,QAAO,SAAS,SAAS;AAG3B,KAAI,CAAC,mBACH,QAAO;AAGT,QACE,oBAAC,uBAAuB,UAAxB;EAAiC,OAAO;GAAE;GAAW,MAAM,sBAAsB;GAAM;EACpF;EAC+B,CAAA"}

package/dist/src/modules/billing/hooks/useSubscription.d.mts

@@ -0,0 +1,10 @@
+import * as _$_m5kdev_commons_modules_billing_billing_schema0 from "@m5kdev/commons/modules/billing/billing.schema";
+
+//#region src/modules/billing/hooks/useSubscription.d.ts
+declare function useSubscription(): {
+  isLoading: boolean;
+  data: _$_m5kdev_commons_modules_billing_billing_schema0.BillingSchema | null;
+};
+//#endregion
+export { useSubscription };
+//# sourceMappingURL=useSubscription.d.mts.map

package/dist/src/modules/billing/hooks/useSubscription.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSubscription.d.mts","names":[],"sources":["../../../../../src/modules/billing/hooks/useSubscription.ts"],"mappings":";;;iBAGgB,eAAA,CAAA;;QAAe,iDAAA,CAAA,aAAA;AAAA"}

package/dist/src/modules/billing/hooks/useSubscription.mjs

@@ -0,0 +1,10 @@
+import { billingProviderContext } from "../components/BillingProvider.mjs";
+import { useContext } from "react";
+//#region src/modules/billing/hooks/useSubscription.ts
+function useSubscription() {
+	return useContext(billingProviderContext);
+}
+//#endregion
+export { useSubscription };
+
+//# sourceMappingURL=useSubscription.mjs.map

package/dist/src/modules/billing/hooks/useSubscription.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSubscription.mjs","names":[],"sources":["../../../../../src/modules/billing/hooks/useSubscription.ts"],"sourcesContent":["import { useContext } from \"react\";\r\nimport { billingProviderContext } from \"../components/BillingProvider\";\r\n\r\nexport function useSubscription() {\r\n  return useContext(billingProviderContext);\r\n}\r\n"],"mappings":";;;AAGA,SAAgB,kBAAkB;AAChC,QAAO,WAAW,uBAAuB"}

package/dist/src/modules/file/hooks/useS3DownloadUrl.d.mts

@@ -0,0 +1,8 @@
+import * as _$_tanstack_react_query0 from "@tanstack/react-query";
+
+//#region src/modules/file/hooks/useS3DownloadUrl.d.ts
+declare function fetchS3DownloadUrl(filePath: string, serverUrl?: any): Promise<string>;
+declare function useS3DownloadUrl(filePath: string, serverUrl?: any): _$_tanstack_react_query0.UseQueryResult<string, Error>;
+//#endregion
+export { fetchS3DownloadUrl, useS3DownloadUrl };
+//# sourceMappingURL=useS3DownloadUrl.d.mts.map

package/dist/src/modules/file/hooks/useS3DownloadUrl.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useS3DownloadUrl.d.mts","names":[],"sources":["../../../../../src/modules/file/hooks/useS3DownloadUrl.ts"],"mappings":";;;iBAEsB,kBAAA,CACpB,QAAA,UACA,SAAA,SAA2C,OAAA;AAAA,iBAO7B,gBAAA,CAAiB,QAAA,UAAkB,SAAA,SAA2C,wBAAA,CAAA,cAAA,SAAA,KAAA"}

package/dist/src/modules/file/hooks/useS3DownloadUrl.mjs

@@ -0,0 +1,18 @@
+import { useQuery } from "@tanstack/react-query";
+//#region src/modules/file/hooks/useS3DownloadUrl.ts
+async function fetchS3DownloadUrl(filePath, serverUrl = import.meta.env.VITE_SERVER_URL) {
+	const res = await fetch(`${serverUrl}/upload/files/${filePath}`);
+	if (!res.ok) throw new Error("Failed to get download URL");
+	return (await res.json()).url;
+}
+function useS3DownloadUrl(filePath, serverUrl = import.meta.env.VITE_SERVER_URL) {
+	return useQuery({
+		queryKey: ["s3DownloadUrl", filePath],
+		queryFn: () => fetchS3DownloadUrl(filePath, serverUrl),
+		enabled: Boolean(filePath)
+	});
+}
+//#endregion
+export { fetchS3DownloadUrl, useS3DownloadUrl };
+
+//# sourceMappingURL=useS3DownloadUrl.mjs.map

package/dist/src/modules/file/hooks/useS3DownloadUrl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useS3DownloadUrl.mjs","names":[],"sources":["../../../../../src/modules/file/hooks/useS3DownloadUrl.ts"],"sourcesContent":["import { useQuery } from \"@tanstack/react-query\";\r\n\r\nexport async function fetchS3DownloadUrl(\r\n  filePath: string,\r\n  serverUrl = import.meta.env.VITE_SERVER_URL\r\n) {\r\n  const res = await fetch(`${serverUrl}/upload/files/${filePath}`);\r\n  if (!res.ok) throw new Error(\"Failed to get download URL\");\r\n  return (await res.json()).url as string;\r\n}\r\n\r\nexport function useS3DownloadUrl(filePath: string, serverUrl = import.meta.env.VITE_SERVER_URL) {\r\n  return useQuery<string, Error>({\r\n    queryKey: [\"s3DownloadUrl\", filePath],\r\n    queryFn: () => fetchS3DownloadUrl(filePath, serverUrl),\r\n    enabled: Boolean(filePath),\r\n  });\r\n}\r\n"],"mappings":";;AAEA,eAAsB,mBACpB,UACA,YAAY,OAAO,KAAK,IAAI,iBAC5B;CACA,MAAM,MAAM,MAAM,MAAM,GAAG,UAAU,gBAAgB,WAAW;AAChE,KAAI,CAAC,IAAI,GAAI,OAAM,IAAI,MAAM,6BAA6B;AAC1D,SAAQ,MAAM,IAAI,MAAM,EAAE;;AAG5B,SAAgB,iBAAiB,UAAkB,YAAY,OAAO,KAAK,IAAI,iBAAiB;AAC9F,QAAO,SAAwB;EAC7B,UAAU,CAAC,iBAAiB,SAAS;EACrC,eAAe,mBAAmB,UAAU,UAAU;EACtD,SAAS,QAAQ,SAAS;EAC3B,CAAC"}

package/dist/src/modules/file/hooks/useS3Upload.d.mts

@@ -0,0 +1,13 @@
+//#region src/modules/file/hooks/useS3Upload.d.ts
+type S3UploadStatus = "idle" | "uploading" | "success" | "error";
+declare function useS3Upload(serverUrl?: string): {
+  upload: (file: File | Blob, prefix?: string) => Promise<string>;
+  progress: number;
+  status: S3UploadStatus;
+  error: string | null;
+  uploadedUrl: string | null;
+  reset: () => void;
+};
+//#endregion
+export { S3UploadStatus, useS3Upload };
+//# sourceMappingURL=useS3Upload.d.mts.map

package/dist/src/modules/file/hooks/useS3Upload.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useS3Upload.d.mts","names":[],"sources":["../../../../../src/modules/file/hooks/useS3Upload.ts"],"mappings":";KAEY,cAAA;AAAA,iBAiBI,WAAA,CAAY,SAAA;iBAMc,IAAA,GAAO,IAAA,EAAI,MAAA,cAAiB,OAAA"}

package/dist/src/modules/file/hooks/useS3Upload.mjs

@@ -0,0 +1,79 @@
+import { useCallback, useState } from "react";
+//#region src/modules/file/hooks/useS3Upload.ts
+async function getPresignedUrl(filename, filetype, serverUrl = "") {
+	const res = await fetch(`${serverUrl}/upload/s3-presigned-url`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			filename,
+			filetype
+		})
+	});
+	if (!res.ok) throw new Error("Failed to get presigned URL");
+	return (await res.json()).url;
+}
+function useS3Upload(serverUrl = "") {
+	const [progress, setProgress] = useState(0);
+	const [status, setStatus] = useState("idle");
+	const [error, setError] = useState(null);
+	const [uploadedUrl, setUploadedUrl] = useState(null);
+	return {
+		upload: useCallback(async (file, prefix) => {
+			setProgress(0);
+			setStatus("uploading");
+			setError(null);
+			setUploadedUrl(null);
+			try {
+				const extension = (file instanceof File ? file.name : `upload-${Date.now()}`).split(".").pop() || "";
+				const uuid = crypto.randomUUID();
+				const filename = prefix ? `${prefix}/${uuid}.${extension}` : `${uuid}.${extension}`;
+				const filetype = file instanceof File ? file.type : "application/octet-stream";
+				const presignedUrl = await getPresignedUrl(filename, filetype, serverUrl);
+				return await new Promise((resolve, reject) => {
+					const xhr = new XMLHttpRequest();
+					xhr.open("PUT", presignedUrl);
+					xhr.setRequestHeader("Content-Type", filetype);
+					xhr.upload.onprogress = (event) => {
+						if (event.lengthComputable) setProgress(Math.round(event.loaded * 100 / event.total));
+					};
+					xhr.onload = () => {
+						if (xhr.status >= 200 && xhr.status < 300) {
+							setProgress(100);
+							setStatus("success");
+							setUploadedUrl(presignedUrl.split("?")[0]);
+							resolve(filename);
+						} else {
+							setStatus("error");
+							setError(`Upload failed with status ${xhr.status}`);
+							reject(/* @__PURE__ */ new Error(`Upload failed with status ${xhr.status}`));
+						}
+					};
+					xhr.onerror = () => {
+						setStatus("error");
+						setError("Network error during upload");
+						reject(/* @__PURE__ */ new Error("Network error during upload"));
+					};
+					xhr.send(file);
+				});
+			} catch (err) {
+				setStatus("error");
+				setError(err?.message || "Unknown error");
+				return Promise.reject(err);
+			}
+		}, [serverUrl]),
+		progress,
+		status,
+		error,
+		uploadedUrl,
+		reset: useCallback(() => {
+			setProgress(0);
+			setStatus("idle");
+			setError(null);
+			setUploadedUrl(null);
+		}, [])
+	};
+}
+//#endregion
+export { useS3Upload };
+
+//# sourceMappingURL=useS3Upload.mjs.map