Repository navigation
Expand file tree
/
Copy pathserviceWorkerRegistration.js
More file actions
203 lines (184 loc) · 7.73 KB
/
Copy pathserviceWorkerRegistration.js
File metadata and controls
203 lines (184 loc) · 7.73 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
// This optional code is used to register a service worker.
// register() is not called by default.
// This lets the app load faster on subsequent visits in production, and gives
// it offline capabilities. A deployed update is picked up on the next resume:
// the page asks for a new worker whenever it becomes visible, and reloads once
// that worker takes control.
// To learn more about the benefits of this model and instructions on how to
// opt-in, read https://cra.link/PWA
// webpack injected PUBLIC_URL into the bundle; Metro does not. The build is
// served from the site root, so this is the empty string. Without it the
// worker URL would be the literal string "undefined/service-worker.js".
const PUBLIC_URL = '';
// Service workers are a browser API. Expo's dev runtime polyfills
// window.location, but a release bundle on a phone has no window at all, so
// this must survive the module loading where one does not exist.
const isLocalhost = Boolean(
typeof window !== 'undefined' &&
window.location &&
(window.location.hostname === 'localhost' ||
// [::1] is the IPv6 localhost address.
window.location.hostname === '[::1]' ||
// 127.0.0.0/8 are considered localhost for IPv4.
window.location.hostname.match(/^127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/))
);
export function register(config) {
const isEnvProduction = process.env.NODE_ENV === 'production';
if (isEnvProduction && 'serviceWorker' in navigator) {
// The URL constructor is available in all browsers that support SW.
const publicUrl = new URL(PUBLIC_URL || '/', window.location.href);
if (publicUrl.origin !== window.location.origin) {
// Our service worker won't work if PUBLIC_URL is on a different origin
// from what our page is served on. This might happen if a CDN is used to
// serve assets; see https://github.com/facebook/create-react-app/issues/2374
return;
}
window.addEventListener('load', () => {
const swUrl = `${PUBLIC_URL}/service-worker.js`;
if (isLocalhost) {
// This is running on localhost. Let's check if a service worker still exists or not.
checkValidServiceWorker(swUrl, config);
// Add some additional logging to localhost, pointing developers to the
// service worker/PWA documentation.
navigator.serviceWorker.ready.then(() => {
console.log(
'This web app is being served cache-first by a service ' +
'worker. To learn more, visit https://cra.link/PWA'
);
});
} else {
// Is not localhost. Just register service worker
registerValidSW(swUrl, config);
}
});
}
}
// An installed PWA is suspended when you leave it and resumed when you come
// back, so it can run for weeks without ever loading the page again. Nothing
// would go looking for a new worker in that time. Ask on every resume, and the
// check costs one conditional request against a worker that answers 304.
//
// pageshow as well as visibilitychange: iOS has not been dependable about
// firing visibilitychange when a home-screen app is resumed, and a resume that
// never asks is the whole failure this is here to prevent.
//
// update() rejects whenever the network is down, which for a shopping app in a
// supermarket is an ordinary Tuesday. Sentry captures unhandled rejections, so
// swallowing it is what keeps every offline resume out of the issue list.
function checkForUpdateOnResume(registration) {
const ask = () => registration.update().catch(() => {});
document.addEventListener('visibilitychange', () => {
if (document.visibilityState === 'visible') ask();
});
window.addEventListener('pageshow', ask);
}
// The worker skips waiting, so a new one takes control while the page is still
// showing the build the old one served. Reloading is what puts the new build on
// screen.
//
// It waits for the page to be hidden first. Navigation state is not restored
// (App.js keeps setInitialNavigationState off), so a reload drops you on the
// default tab at the top. Doing that under someone halfway down their cart is
// worse than being a version behind for one more resume.
//
// A page that loaded with no worker is claimed by the one it just installed.
// That first claim is not an update, so it is swallowed. Every later one is a
// new build, and the listener has to be attached either way: a freshly
// installed home-screen app always loads uncontrolled the first time, and that
// is precisely the page that then stays open for weeks.
function reloadWhenTheNewWorkerTakesOver() {
let controlled = Boolean(navigator.serviceWorker.controller);
let pending = false;
const reloadWhenHidden = () => {
if (!pending || document.visibilityState !== 'hidden') return;
document.removeEventListener('visibilitychange', reloadWhenHidden);
window.location.reload();
};
navigator.serviceWorker.addEventListener('controllerchange', () => {
if (!controlled) {
controlled = true;
return;
}
if (pending) return;
pending = true;
document.addEventListener('visibilitychange', reloadWhenHidden);
reloadWhenHidden();
});
}
function registerValidSW(swUrl, config) {
navigator.serviceWorker
.register(swUrl)
.then((registration) => {
reloadWhenTheNewWorkerTakesOver();
checkForUpdateOnResume(registration);
registration.onupdatefound = () => {
const installingWorker = registration.installing;
if (installingWorker == null) {
return;
}
installingWorker.onstatechange = () => {
if (installingWorker.state === 'installed') {
if (navigator.serviceWorker.controller) {
// The new worker activates itself from here, and the
// controllerchange listener above reloads the page onto it.
console.log('New content is available; reloading.');
// Execute callback
if (config && config.onUpdate) {
config.onUpdate(registration);
}
} else {
// At this point, everything has been precached.
// It's the perfect time to display a
// "Content is cached for offline use." message.
console.log('Content is cached for offline use.');
// Execute callback
if (config && config.onSuccess) {
config.onSuccess(registration);
}
}
}
};
};
})
.catch((error) => {
console.error('Error during service worker registration:', error);
});
}
function checkValidServiceWorker(swUrl, config) {
// Check if the service worker can be found. If it can't reload the page.
fetch(swUrl, {
headers: { 'Service-Worker': 'script' },
})
.then((response) => {
// Ensure service worker exists, and that we really are getting a JS file.
const contentType = response.headers.get('content-type');
if (
response.status === 404 ||
(contentType != null && contentType.indexOf('javascript') === -1)
) {
// No service worker found. Probably a different app. Reload the page.
navigator.serviceWorker.ready.then((registration) => {
registration.unregister().then(() => {
window.location.reload();
});
});
} else {
// Service worker found. Proceed as normal.
registerValidSW(swUrl, config);
}
})
.catch(() => {
console.log('No internet connection found. App is running in offline mode.');
});
}
export function unregister() {
if ('serviceWorker' in navigator) {
navigator.serviceWorker.ready
.then((registration) => {
registration.unregister();
})
.catch((error) => {
console.error(error.message);
});
}
}