@saas-ui/auth-provider
Version:
Authentication provider primivites
269 lines (265 loc) • 8.09 kB
JavaScript
'use client'
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var src_exports = {};
__export(src_exports, {
AuthContext: () => AuthContext,
AuthProvider: () => AuthProvider,
useAuth: () => useAuth,
useCurrentUser: () => useCurrentUser,
useLogin: () => useLogin,
useOtp: () => useOtp,
useResetPassword: () => useResetPassword,
useSignUp: () => useSignUp,
useUpdatePassword: () => useUpdatePassword
});
module.exports = __toCommonJS(src_exports);
// src/provider.tsx
var import_react = __toESM(require("react"));
// src/use-promise.ts
var React = __toESM(require("react"));
function usePromise(fn) {
const [isLoading, setLoading] = React.useState(false);
const [isResolved, setResolved] = React.useState(false);
const [isRejected, setRejected] = React.useState(false);
const [error, setError] = React.useState(null);
const [data, setData] = React.useState(null);
const call = (...params) => {
setLoading(true);
return fn(...params).then((data2) => {
setData(data2);
setResolved(true);
setLoading(false);
return data2;
}).catch((err) => {
setError(err);
setRejected(true);
setLoading(false);
throw err;
});
};
return [{ error, data, isLoading, isResolved, isRejected }, call];
}
// src/provider.tsx
var import_jsx_runtime = require("react/jsx-runtime");
var createAuthContext = () => {
return (0, import_react.createContext)(null);
};
var AuthContext = createAuthContext();
var AuthProvider = ({
refetchUserOnWindowFocus = true,
onRestoreAuthState,
onLoadUser = () => Promise.resolve(null),
onSignup = () => Promise.resolve(null),
onLogin = () => Promise.resolve(null),
onVerifyOtp = () => Promise.resolve(null),
onLogout = () => Promise.resolve(),
onAuthStateChange,
onGetToken,
onResetPassword,
onUpdatePassword,
children
}) => {
const [isAuthenticated, setAuthenticated] = (0, import_react.useState)(false);
const [user, setUser] = (0, import_react.useState)();
const [isLoading, setLoading] = (0, import_react.useState)(true);
const restoreRef = import_react.default.useRef(false);
const isFetchingRef = import_react.default.useRef(false);
const [error, setError] = (0, import_react.useState)(null);
(0, import_react.useEffect)(() => {
if (onAuthStateChange) {
const unsubscribe = onAuthStateChange((user2) => {
setAuthenticated(!!user2);
});
return () => {
unsubscribe == null ? void 0 : unsubscribe();
};
}
}, []);
(0, import_react.useEffect)(() => {
const restoreState = async () => {
restoreRef.current = true;
await (onRestoreAuthState == null ? void 0 : onRestoreAuthState());
await loadUser();
restoreRef.current = false;
};
if (!restoreRef.current) {
restoreState();
}
}, [onRestoreAuthState]);
const loadUser = (0, import_react.useCallback)(async () => {
try {
if (isFetchingRef.current) {
return;
}
setError(null);
if ((typeof onGetToken === "undefined" || await onGetToken()) && !isFetchingRef.current) {
isFetchingRef.current = true;
const user2 = await onLoadUser();
if (user2) {
setUser(user2);
setAuthenticated(true);
} else {
setAuthenticated(false);
setUser(null);
}
}
} catch (error2) {
setError(error2);
setAuthenticated(false);
setUser(null);
} finally {
isFetchingRef.current = false;
setLoading(false);
}
}, [onLoadUser, onGetToken]);
(0, import_react.useEffect)(() => {
if (!refetchUserOnWindowFocus) {
return;
}
const onWindowFocus = async () => {
loadUser();
};
window.addEventListener("focus", onWindowFocus);
return () => {
if (onWindowFocus) {
window.removeEventListener("focus", onWindowFocus);
}
};
}, [loadUser, refetchUserOnWindowFocus]);
const signUp = (0, import_react.useCallback)(
async (params, options) => {
const result = await onSignup(params, options);
loadUser();
return result;
},
[onSignup]
);
const logIn = (0, import_react.useCallback)(
async (params, options) => {
const result = await onLogin(params, options);
loadUser();
return result;
},
[onLogin]
);
const logOut = (0, import_react.useCallback)(
async (options) => {
await onLogout(options);
setUser(null);
setAuthenticated(false);
},
[onLogout]
);
const verifyOtp = (0, import_react.useCallback)(
async (params, options) => {
const result = await onVerifyOtp(params, options);
return result;
},
[onVerifyOtp]
);
const resetPassword = (0, import_react.useCallback)(
async (params, options) => {
return await (onResetPassword == null ? void 0 : onResetPassword(params, options));
},
[onResetPassword]
);
const updatePassword = (0, import_react.useCallback)(
async (params, options) => {
return await (onUpdatePassword == null ? void 0 : onUpdatePassword(params, options));
},
[onUpdatePassword]
);
const getToken = (0, import_react.useCallback)(async () => {
return onGetToken == null ? void 0 : onGetToken();
}, [onGetToken]);
const value = {
isAuthenticated,
isLoggingIn: isAuthenticated && !user,
isLoading,
user,
signUp,
logIn,
logOut,
verifyOtp,
loadUser,
getToken,
resetPassword,
updatePassword,
error
};
return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AuthContext.Provider, { value, children });
};
var useAuth = () => {
const context = (0, import_react.useContext)(AuthContext);
if (context === null) {
throw new Error(
"Auth context missing, did you forget to wrap your app in AuthProvider?"
);
}
return context;
};
var useCurrentUser = () => {
return useAuth().user;
};
var useLogin = ({ action = "logIn" } = {}) => {
const auth = useAuth();
const fn = auth[action] || auth["logIn"];
return usePromise(fn);
};
var useSignUp = () => {
const { signUp } = useAuth();
return usePromise(signUp);
};
var useOtp = () => {
const { verifyOtp } = useAuth();
return usePromise(verifyOtp);
};
var useResetPassword = () => {
const { resetPassword } = useAuth();
return usePromise(resetPassword);
};
var useUpdatePassword = () => {
const { updatePassword } = useAuth();
return usePromise(updatePassword);
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
AuthContext,
AuthProvider,
useAuth,
useCurrentUser,
useLogin,
useOtp,
useResetPassword,
useSignUp,
useUpdatePassword
});
//# sourceMappingURL=index.js.map