expo-router
Version:
Expo Router is a file-based router for React Native and web applications.
350 lines (348 loc) • 10.8 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
0 && (module.exports = {
canDismiss: null,
canGoBack: null,
createImperativeRouter: null,
dismiss: null,
dismissAll: null,
dismissTo: null,
getDefaultTransitionMode: null,
goBack: null,
linkTo: null,
navigate: null,
prefetch: null,
push: null,
reload: null,
replace: null,
router: null,
setParams: null,
unboundRouter: null
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: Object.getOwnPropertyDescriptor(all, name).get
});
}
_export(exports, {
get canDismiss () {
return canDismiss;
},
get canGoBack () {
return canGoBack;
},
get createImperativeRouter () {
return createImperativeRouter;
},
get dismiss () {
return dismiss;
},
get dismissAll () {
return dismissAll;
},
get dismissTo () {
return dismissTo;
},
get getDefaultTransitionMode () {
return getDefaultTransitionMode;
},
get goBack () {
return goBack;
},
get linkTo () {
return linkTo;
},
get navigate () {
return navigate;
},
get prefetch () {
return prefetch;
},
get push () {
return push;
},
get reload () {
return reload;
},
get replace () {
return replace;
},
get router () {
return router;
},
get setParams () {
return setParams;
},
get unboundRouter () {
return unboundRouter;
}
});
function _expolinking() {
const data = /*#__PURE__*/ _interop_require_wildcard(require("expo-linking"));
_expolinking = function() {
return data;
};
return data;
}
function _dom() {
const data = require("expo/dom");
_dom = function() {
return data;
};
return data;
}
function _reactnative() {
const data = require("react-native");
_reactnative = function() {
return data;
};
return data;
}
const _emitDomEvent = require("../domComponents/emitDomEvent");
const _href = require("../link/href");
const _CanDismissContext = require("../react-navigation/core/CanDismissContext");
const _url = require("../utils/url");
const _navigationRef = require("./navigationRef");
function _getRequireWildcardCache(nodeInterop) {
if (typeof WeakMap !== "function") return null;
var cacheBabelInterop = new WeakMap();
var cacheNodeInterop = new WeakMap();
return (_getRequireWildcardCache = function(nodeInterop) {
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
})(nodeInterop);
}
function _interop_require_wildcard(obj, nodeInterop) {
if (!nodeInterop && obj && obj.__esModule) {
return obj;
}
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
return {
default: obj
};
}
var cache = _getRequireWildcardCache(nodeInterop);
if (cache && cache.has(obj)) {
return cache.get(obj);
}
var newObj = {
__proto__: null
};
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
for(var key in obj){
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
if (desc && (desc.get || desc.set)) {
Object.defineProperty(newObj, key, desc);
} else {
newObj[key] = obj[key];
}
}
}
newObj.default = obj;
if (cache) {
cache.set(obj, newObj);
}
return newObj;
}
function assertIsMounted() {
if (_navigationRef.navigationRef.current == null) {
throw new Error('Attempted to navigate before mounting the Root Layout component. Ensure the Root Layout component is rendering a Slot, or other navigator on the first render.');
}
}
function navigateImpl(enqueue, url, options) {
return linkToImpl(enqueue, (0, _href.resolveHref)(url), {
...options,
event: 'NAVIGATE'
});
}
function reload() {
// TODO(EvanBacon): add `reload` support.
throw new Error('The reload method is not implemented in the client-side router yet.');
}
function prefetchImpl(enqueue, href, options) {
return linkToImpl(enqueue, (0, _href.resolveHref)(href), {
...options,
event: 'PRELOAD'
});
}
function pushImpl(enqueue, url, options) {
return linkToImpl(enqueue, (0, _href.resolveHref)(url), {
...options,
event: 'PUSH'
});
}
function enqueueAction(enqueue, action, inTransition) {
enqueue({
type: 'ACTION',
payload: {
action
},
inTransition
});
}
// `GO_BACK` follows focused back handling; `POP` explicitly removes stack routes.
function dismissImpl(enqueue, count = 1, options) {
if ((0, _emitDomEvent.emitDomDismiss)(count, options)) {
return;
}
enqueueAction(enqueue, {
type: 'POP',
payload: {
count
}
}, options?.inTransition);
}
function dismissToImpl(enqueue, href, options) {
return linkToImpl(enqueue, (0, _href.resolveHref)(href), {
...options,
event: 'POP_TO'
});
}
function replaceImpl(enqueue, url, options) {
return linkToImpl(enqueue, (0, _href.resolveHref)(url), {
...options,
event: 'REPLACE'
});
}
function dismissAllImpl(enqueue, options) {
if ((0, _emitDomEvent.emitDomDismissAll)(options)) {
return;
}
enqueueAction(enqueue, {
type: 'POP_TO_TOP'
}, options?.inTransition);
}
// `GO_BACK` follows focused back handling; `POP` (used by `dismiss`) explicitly removes stack routes.
function goBackImpl(enqueue, options) {
if ((0, _emitDomEvent.emitDomGoBack)(options)) {
return;
}
enqueueAction(enqueue, {
type: 'GO_BACK'
}, options?.inTransition);
}
function canGoBack() {
if (_dom().IS_DOM) {
throw new Error('canGoBack imperative method is not supported. Pass the property to the DOM component instead.');
}
// Return a default value here if the navigation hasn't mounted yet.
// This can happen if the user calls `canGoBack` from the Root Layout route
// before mounting a navigator. This behavior exists due to React Navigation being dynamically
// constructed at runtime. We can get rid of this in the future if we use
// the static configuration internally.
if (_navigationRef.navigationRef.current == null) {
return false;
}
return _navigationRef.navigationRef.current.canGoBack();
}
function canDismiss() {
if (_dom().IS_DOM) {
throw new Error('canDismiss imperative method is not supported. Pass the property to the DOM component instead.');
}
if (_navigationRef.navigationRef.current == null) {
return false;
}
// TODO(@ubax): check whether this is still needed
return (0, _CanDismissContext.getCanDismiss)(_navigationRef.navigationRef.getRootState());
}
function setParams(params = {}) {
if ((0, _emitDomEvent.emitDomSetParams)(params)) {
return;
}
assertIsMounted();
return _navigationRef.navigationRef.current.setParams(params);
}
function linkToImpl(enqueue, originalHref, options = {}) {
const { inTransition, ...navigationOptions } = options;
let href = typeof originalHref == 'string' ? originalHref : (0, _href.resolveHref)(originalHref);
if ((0, _emitDomEvent.emitDomLinkEvent)(href, options)) {
return;
}
if ((0, _url.shouldLinkExternally)(href)) {
if (href.startsWith('//') && _reactnative().Platform.OS !== 'web') {
href = `https:${href}`;
}
_expolinking().openURL(href);
return;
}
if (href === '..' || href === '../') {
return goBackImpl(enqueue, {
inTransition
});
}
// TODO(@ubax): Extract this change to standalone PR
const linkAction = {
type: 'NAVIGATE_TO_HREF',
payload: {
href,
options: navigationOptions
},
inTransition
};
enqueue(linkAction);
}
function createImperativeRouter(enqueue, setTransitionMode) {
return {
navigate: (href, options)=>navigateImpl(enqueue, href, options),
push: (href, options)=>pushImpl(enqueue, href, options),
dismiss: (count, options)=>dismissImpl(enqueue, count, options),
dismissAll: (options)=>dismissAllImpl(enqueue, options),
dismissTo: (href, options)=>dismissToImpl(enqueue, href, options),
canDismiss,
replace: (href, options)=>replaceImpl(enqueue, href, options),
back: (options)=>goBackImpl(enqueue, options),
goBack: (options)=>goBackImpl(enqueue, options),
canGoBack,
reload,
prefetch: (href, options)=>prefetchImpl(enqueue, href, options),
setTransitionMode: (mode)=>{
setDefaultTransitionMode(mode);
setTransitionMode(mode);
},
setParams: setParams,
linkTo: (href, options)=>linkToImpl(enqueue, href, options)
};
}
const throwBeforeFirstRender = ()=>{
throw new Error('The imperative router is unavailable before the first render has finished.');
};
let defaultTransitionMode = 'preload-only';
function getDefaultTransitionMode() {
return defaultTransitionMode;
}
function setDefaultTransitionMode(mode) {
defaultTransitionMode = mode;
}
const unboundRouter = {
navigate: throwBeforeFirstRender,
push: throwBeforeFirstRender,
dismiss: throwBeforeFirstRender,
dismissAll: throwBeforeFirstRender,
dismissTo: throwBeforeFirstRender,
canDismiss: throwBeforeFirstRender,
replace: throwBeforeFirstRender,
back: throwBeforeFirstRender,
goBack: throwBeforeFirstRender,
canGoBack: throwBeforeFirstRender,
reload: throwBeforeFirstRender,
prefetch: throwBeforeFirstRender,
setTransitionMode: setDefaultTransitionMode,
setParams: throwBeforeFirstRender,
linkTo: throwBeforeFirstRender
};
const router = {
...unboundRouter
};
const navigate = (...args)=>router.navigate(...args);
const push = (...args)=>router.push(...args);
const dismiss = (...args)=>router.dismiss(...args);
const dismissAll = (...args)=>router.dismissAll(...args);
const dismissTo = (...args)=>router.dismissTo(...args);
const replace = (...args)=>router.replace(...args);
const goBack = (...args)=>router.goBack(...args);
const prefetch = (...args)=>router.prefetch(...args);
const linkTo = (...args)=>router.linkTo(...args);
//# sourceMappingURL=router.js.map