reactfire
Version:
Firebase library for React
471 lines (458 loc) • 17.8 kB
JavaScript
;
Object.defineProperty(exports, '__esModule', { value: true });
var React = require('react');
var auth = require('rxfire/auth');
var rxjs = require('rxjs');
var database = require('rxfire/database');
var firebase = require('firebase/app');
var firestore = require('rxfire/firestore');
var operators = require('rxjs/operators');
var storage = require('rxfire/storage');
function preloadUser(firebaseApp) {
return preloadAuth(firebaseApp).then(function (auth$1) {
var result = preloadObservable(auth.user(auth$1()), 'auth: user');
return result.request.promise;
});
}
function useUser(auth$1, options) {
auth$1 = auth$1 || useAuth()();
var currentUser = undefined;
if (options && options.startWithValue !== undefined) {
currentUser = options.startWithValue;
}
else if (auth$1.currentUser) {
currentUser = auth$1.currentUser;
}
return useObservable(auth.user(auth$1), 'auth: user', currentUser);
}
function useIdTokenResult(user, forceRefresh) {
if (forceRefresh === void 0) { forceRefresh = false; }
if (!user) {
throw new Error('you must provide a user');
}
var idToken$ = rxjs.from(user.getIdTokenResult(forceRefresh));
return useObservable(idToken$, user.uid + "-claims");
}
function ClaimsCheck(_a) {
var user = _a.user, fallback = _a.fallback, children = _a.children, requiredClaims = _a.requiredClaims;
var claims = useIdTokenResult(user, false).claims;
var missingClaims = {};
Object.keys(requiredClaims).forEach(function (claim) {
if (requiredClaims[claim] !== claims[claim]) {
missingClaims[claim] = {
expected: requiredClaims[claim],
actual: claims[claim]
};
}
});
if (Object.keys(missingClaims).length === 0) {
return React.createElement(React.Fragment, null, children);
}
else {
return React.createElement(React.Fragment, null, fallback);
}
}
function AuthCheck(_a) {
var auth = _a.auth, fallback = _a.fallback, children = _a.children, requiredClaims = _a.requiredClaims;
var user = useUser(auth);
if (user) {
return requiredClaims ? (React.createElement(ClaimsCheck, { user: user, fallback: fallback, requiredClaims: requiredClaims }, children)) : (React.createElement(React.Fragment, null, children));
}
else {
return React.createElement(React.Fragment, null, fallback);
}
}
function useDatabaseObject(ref, options) {
return useObservable(database.object(ref), "RTDB: " + ref.toString(), options ? options.startWithValue : undefined);
}
function useDatabaseList(ref, options) {
var hash = "RTDB: " + ref.toString() + "|" + ref.queryIdentifier();
return useObservable(database.list(ref), hash, options ? options.startWithValue : undefined);
}
var SDK;
(function (SDK) {
SDK["ANALYTICS"] = "analytics";
SDK["AUTH"] = "auth";
SDK["DATABASE"] = "database";
SDK["FIRESTORE"] = "firestore";
SDK["FUNCTIONS"] = "functions";
SDK["MESSAGING"] = "messaging";
SDK["PERFORMANCE"] = "performance";
SDK["REMOTE_CONFIG"] = "remoteConfig";
SDK["STORAGE"] = "storage";
})(SDK || (SDK = {}));
function fetchSDK(sdk, firebaseApp) {
if (!firebaseApp) {
throw new Error('Firebase app was not provided');
}
var sdkPromise;
if (firebaseApp[sdk]) {
sdkPromise = Promise.resolve(firebaseApp[sdk]);
}
else {
switch (sdk) {
case SDK.FIRESTORE:
sdkPromise = new Promise(function (resolve) { resolve(require('./index.esm-22629071.js')); });
break;
case SDK.DATABASE:
sdkPromise = new Promise(function (resolve) { resolve(require('./index.esm-e89c2c70.js')); });
break;
case SDK.AUTH:
sdkPromise = new Promise(function (resolve) { resolve(require('./index.esm-24615fcd.js')); });
break;
case SDK.STORAGE:
sdkPromise = new Promise(function (resolve) { resolve(require('./index.esm-a8cc91ba.js')); });
break;
case SDK.PERFORMANCE:
sdkPromise = new Promise(function (resolve) { resolve(require('./index.esm-8c579783.js')); });
break;
}
sdkPromise = sdkPromise.then(function () { return firebaseApp[sdk]; });
}
return sdkPromise;
}
function useSDK(sdk, firebaseApp) {
firebaseApp = firebaseApp || useFirebaseApp();
var result = preloadRequest(function () { return fetchSDK(sdk, firebaseApp); }, "firebase-sdk-" + sdk);
return usePreloadedRequest(result);
}
function preloadAuth(firebaseApp) {
return fetchSDK(SDK.AUTH, firebaseApp);
}
function useAuth(firebaseApp) {
return useSDK(SDK.AUTH, firebaseApp);
}
function preloadAnalytics(firebaseApp) {
return fetchSDK(SDK.ANALYTICS, firebaseApp);
}
function useAnalytics(firebaseApp) {
return useSDK(SDK.ANALYTICS, firebaseApp);
}
function preloadDatabase(firebaseApp) {
return fetchSDK(SDK.DATABASE, firebaseApp);
}
function useDatabase(firebaseApp) {
return useSDK(SDK.DATABASE, firebaseApp);
}
function preloadFirestore(firebaseApp) {
return fetchSDK(SDK.FIRESTORE, firebaseApp);
}
function useFirestore(firebaseApp) {
return useSDK(SDK.FIRESTORE, firebaseApp);
}
function preloadFunctions(firebaseApp) {
return fetchSDK(SDK.FUNCTIONS, firebaseApp);
}
function useFunctions(firebaseApp) {
return useSDK(SDK.FUNCTIONS, firebaseApp);
}
function preloadMessaging(firebaseApp) {
return fetchSDK(SDK.MESSAGING, firebaseApp);
}
function useMessaging(firebaseApp) {
return useSDK(SDK.MESSAGING, firebaseApp);
}
function preloadPerformance(firebaseApp) {
return fetchSDK(SDK.PERFORMANCE, firebaseApp);
}
function usePerformance(firebaseApp) {
return useSDK(SDK.PERFORMANCE, firebaseApp);
}
function preloadRemoteConfig(firebaseApp) {
return fetchSDK(SDK.REMOTE_CONFIG, firebaseApp);
}
function useRemoteConfig(firebaseApp) {
return useSDK(SDK.REMOTE_CONFIG, firebaseApp);
}
function preloadStorage(firebaseApp) {
return fetchSDK(SDK.STORAGE, firebaseApp);
}
function useStorage(firebaseApp) {
return useSDK(SDK.STORAGE, firebaseApp);
}
var __assign = (undefined && undefined.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var FirebaseAppContext = React.createContext(undefined);
function FirebaseAppProvider(props) {
var firebaseConfig = props.firebaseConfig, initPerformance = props.initPerformance;
var firebaseApp = props.firebaseApp;
firebaseApp =
firebaseApp ||
React.useMemo(function () {
if (!firebase.apps.length) {
firebase.initializeApp(firebaseConfig);
}
return firebase;
}, [firebaseConfig]);
React.useMemo(function () {
if (initPerformance === true && !!firebase.apps.length) {
if (!firebase.performance) {
throw new Error('firebase.performance not found. Did you forget to import it?');
}
firebase.performance();
}
}, [initPerformance, firebaseApp]);
return React.createElement(FirebaseAppContext.Provider, __assign({ value: firebaseApp }, props));
}
function useFirebaseApp() {
var firebaseApp = React.useContext(FirebaseAppContext);
if (!firebaseApp) {
throw new Error('Cannot call useFirebaseApp unless your component is within a FirebaseAppProvider');
}
return firebaseApp;
}
var ActiveRequest = (function () {
function ActiveRequest(promise) {
var _this = this;
this.setValue = function (value) {
_this.value = value;
_this.isComplete = true;
};
this.setError = function (err) {
_this.error = err;
_this.isComplete = true;
};
this.isComplete = false;
this.promise = promise
.then(function (result) {
_this.setValue(result);
return result;
})
.catch(function (err) {
_this.isComplete = true;
_this.setError(err);
});
}
return ActiveRequest;
}());
var ObservablePromiseCache = (function () {
function ObservablePromiseCache() {
this.activeRequests = new Map();
}
ObservablePromiseCache.prototype.getRequest = function (requestId) {
var request = this.activeRequests.get(requestId);
if (request === undefined) {
throw new Error("No\u00A0request\u00A0with\u00A0ID\u00A0\"" + requestId + "\"\u00A0exists");
}
return request;
};
ObservablePromiseCache.prototype.createRequest = function (promise, requestId) {
if (this.activeRequests.get(requestId) !== undefined) {
throw new Error("request\u00A0\"" + requestId + "\"\u00A0is\u00A0already\u00A0in\u00A0use.");
}
var request = new ActiveRequest(promise);
this.activeRequests.set(requestId, request);
return request;
};
ObservablePromiseCache.prototype.createDedupedRequest = function (getPromise, requestId) {
var request = this.activeRequests.get(requestId);
if (request === undefined) {
request = this.createRequest(getPromise(), requestId);
}
return request;
};
ObservablePromiseCache.prototype.removeRequest = function (requestId) {
this.activeRequests.delete(requestId);
};
return ObservablePromiseCache;
}());
var requestCache = new ObservablePromiseCache();
function preloadRequest(getPromise, requestId) {
var request = requestCache.createDedupedRequest(getPromise, requestId);
return {
requestId: requestId,
request: request
};
}
function preloadObservable(observable$, observableId) {
return preloadRequest(function () { return observable$.pipe(operators.first()).toPromise(); }, observableId);
}
function usePreloadedRequest(preloadResult) {
var request = requestCache.getRequest(preloadResult.requestId);
if (!request.isComplete) {
throw request.promise;
}
if (request.error) {
throw request.error;
}
return request.value;
}
function useObservable(observable$, observableId, startWithValue) {
if (!observableId) {
throw new Error('cannot call useObservable without an observableId');
}
var result = preloadObservable(observable$, observableId);
var initialValue = startWithValue;
if (initialValue === undefined) {
initialValue = usePreloadedRequest(result);
}
var _a = React.useState(initialValue), latestValue = _a[0], setValue = _a[1];
React.useEffect(function () {
var subscription = observable$.pipe(operators.startWith(initialValue)).subscribe(function (newVal) {
result.request.setValue(newVal);
setValue(newVal);
}, function (error) {
console.error('There was an error', error);
throw error;
});
return function () {
subscription.unsubscribe();
requestCache.removeRequest(observableId);
};
}, [observableId]);
return latestValue;
}
function preloadFirestoreDoc(refProvider, firebaseApp) {
return preloadFirestore(firebaseApp).then(function (firestore$1) {
var ref = refProvider(firestore$1());
return preloadObservable(firestore.doc(ref), ref.path);
});
}
function useFirestoreDoc(ref, options) {
return useObservable(firestore.doc(ref), 'firestore doc: ' + ref.path, options ? options.startWithValue : undefined);
}
function useFirestoreDocData(ref, options) {
return useObservable(firestore.docData(ref, checkIdField(options)), 'firestore docdata: ' + ref.path, checkStartWithValue(options));
}
function useFirestoreCollection(query, options) {
var queryId = getHashFromFirestoreQuery(query);
return useObservable(firestore.fromCollectionRef(query, checkIdField(options)), queryId, options ? options.startWithValue : undefined);
}
function getHashFromFirestoreQuery(query) {
var hash = query._query.canonicalId();
return "firestore: " + hash;
}
function useFirestoreCollectionData(query, options) {
var queryId = getHashFromFirestoreQuery(query);
return useObservable(firestore.collectionData(query, checkIdField(options)), queryId, checkStartWithValue(options));
}
function checkOptions(options, field) {
return options ? options[field] : undefined;
}
function checkStartWithValue(options) {
return checkOptions(options, 'startWithValue');
}
function checkIdField(options) {
return checkOptions(options, 'idField');
}
function getPerfFromContext() {
var firebaseApp = useFirebaseApp();
if (!firebaseApp) {
throw new Error('Firebase not found in context. Either pass it directly to a reactfire hook, or wrap your component in a FirebaseAppProvider');
}
var perfFunc = firebaseApp.performance;
if (!perfFunc || !perfFunc()) {
throw new Error("No perf object off of Firebase. Did you forget to import 'firebase/performance' in a component?");
}
return perfFunc();
}
function SuspenseWithPerf(_a) {
var children = _a.children, traceId = _a.traceId, fallback = _a.fallback, firePerf = _a.firePerf;
firePerf = firePerf || getPerfFromContext();
var Fallback = function () {
React.useLayoutEffect(function () {
var trace = firePerf.trace(traceId);
trace.start();
return function () {
trace.stop();
};
}, [traceId]);
return React.createElement(React.Fragment, null, fallback);
};
return React.createElement(React.Suspense, { fallback: React.createElement(Fallback, null) }, children);
}
var __assign$1 = (undefined && undefined.__assign) || function () {
__assign$1 = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign$1.apply(this, arguments);
};
var __rest = (undefined && undefined.__rest) || function (s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
};
function _fromTask(task) {
return new rxjs.Observable(function (subscriber) {
var progress = function (snap) {
return subscriber.next(snap);
};
var error = function (e) { return subscriber.error(e); };
var complete = function () {
return subscriber.complete();
};
task.on('state_changed', progress, error, complete);
});
}
function useStorageTask(task, ref, options) {
return useObservable(_fromTask(task), 'storage upload: ' + ref.toString(), options ? options.startWithValue : undefined);
}
function useStorageDownloadURL(ref, options) {
return useObservable(storage.getDownloadURL(ref), 'storage download:' + ref.toString(), options ? options.startWithValue : undefined);
}
function StorageImage(props) {
var storage = props.storage, storagePath = props.storagePath, imgProps = __rest(props, ["storage", "storagePath"]);
storage = storage || useFirebaseApp().storage();
var imgSrc = useStorageDownloadURL(storage.ref(storagePath));
return React.createElement("img", __assign$1({ src: imgSrc }, imgProps));
}
exports.AuthCheck = AuthCheck;
exports.ClaimsCheck = ClaimsCheck;
exports.FirebaseAppProvider = FirebaseAppProvider;
exports.StorageImage = StorageImage;
exports.SuspenseWithPerf = SuspenseWithPerf;
exports.preloadAnalytics = preloadAnalytics;
exports.preloadAuth = preloadAuth;
exports.preloadDatabase = preloadDatabase;
exports.preloadFirestore = preloadFirestore;
exports.preloadFirestoreDoc = preloadFirestoreDoc;
exports.preloadFunctions = preloadFunctions;
exports.preloadMessaging = preloadMessaging;
exports.preloadObservable = preloadObservable;
exports.preloadPerformance = preloadPerformance;
exports.preloadRemoteConfig = preloadRemoteConfig;
exports.preloadRequest = preloadRequest;
exports.preloadStorage = preloadStorage;
exports.preloadUser = preloadUser;
exports.useAnalytics = useAnalytics;
exports.useAuth = useAuth;
exports.useDatabase = useDatabase;
exports.useDatabaseList = useDatabaseList;
exports.useDatabaseObject = useDatabaseObject;
exports.useFirebaseApp = useFirebaseApp;
exports.useFirestore = useFirestore;
exports.useFirestoreCollection = useFirestoreCollection;
exports.useFirestoreCollectionData = useFirestoreCollectionData;
exports.useFirestoreDoc = useFirestoreDoc;
exports.useFirestoreDocData = useFirestoreDocData;
exports.useFunctions = useFunctions;
exports.useIdTokenResult = useIdTokenResult;
exports.useMessaging = useMessaging;
exports.useObservable = useObservable;
exports.usePerformance = usePerformance;
exports.usePreloadedRequest = usePreloadedRequest;
exports.useRemoteConfig = useRemoteConfig;
exports.useStorage = useStorage;
exports.useStorageDownloadURL = useStorageDownloadURL;
exports.useStorageTask = useStorageTask;
exports.useUser = useUser;