diff options
Diffstat (limited to 'frontend-old/node_modules/web-vitals/src/lib')
19 files changed, 1021 insertions, 0 deletions
diff --git a/frontend-old/node_modules/web-vitals/src/lib/bfcache.ts b/frontend-old/node_modules/web-vitals/src/lib/bfcache.ts new file mode 100644 index 0000000..647b731 --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/bfcache.ts @@ -0,0 +1,36 @@ +/* + * Copyright 2020 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +interface onBFCacheRestoreCallback { + (event: PageTransitionEvent): void; +} + +let bfcacheRestoreTime = -1; + +export const getBFCacheRestoreTime = () => bfcacheRestoreTime; + +export const onBFCacheRestore = (cb: onBFCacheRestoreCallback) => { + addEventListener( + 'pageshow', + (event) => { + if (event.persisted) { + bfcacheRestoreTime = event.timeStamp; + cb(event); + } + }, + true, + ); +}; diff --git a/frontend-old/node_modules/web-vitals/src/lib/bindReporter.ts b/frontend-old/node_modules/web-vitals/src/lib/bindReporter.ts new file mode 100644 index 0000000..fa73db3 --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/bindReporter.ts @@ -0,0 +1,58 @@ +/* + * Copyright 2020 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import {MetricType, MetricRatingThresholds} from '../types.js'; + +const getRating = ( + value: number, + thresholds: MetricRatingThresholds, +): MetricType['rating'] => { + if (value > thresholds[1]) { + return 'poor'; + } + if (value > thresholds[0]) { + return 'needs-improvement'; + } + return 'good'; +}; + +export const bindReporter = <MetricName extends MetricType['name']>( + callback: (metric: Extract<MetricType, {name: MetricName}>) => void, + metric: Extract<MetricType, {name: MetricName}>, + thresholds: MetricRatingThresholds, + reportAllChanges?: boolean, +) => { + let prevValue: number; + let delta: number; + return (forceReport?: boolean) => { + if (metric.value >= 0) { + if (forceReport || reportAllChanges) { + delta = metric.value - (prevValue || 0); + + // Report the metric if there's a non-zero delta or if no previous + // value exists (which can happen in the case of the document becoming + // hidden when the metric value is 0). + // See: https://github.com/GoogleChrome/web-vitals/issues/14 + if (delta || prevValue === undefined) { + prevValue = metric.value; + metric.delta = delta; + metric.rating = getRating(metric.value, thresholds); + callback(metric); + } + } + } + }; +}; diff --git a/frontend-old/node_modules/web-vitals/src/lib/doubleRAF.ts b/frontend-old/node_modules/web-vitals/src/lib/doubleRAF.ts new file mode 100644 index 0000000..c76d142 --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/doubleRAF.ts @@ -0,0 +1,19 @@ +/* + * Copyright 2022 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +export const doubleRAF = (cb: () => unknown) => { + requestAnimationFrame(() => requestAnimationFrame(() => cb())); +}; diff --git a/frontend-old/node_modules/web-vitals/src/lib/generateUniqueID.ts b/frontend-old/node_modules/web-vitals/src/lib/generateUniqueID.ts new file mode 100644 index 0000000..637d013 --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/generateUniqueID.ts @@ -0,0 +1,24 @@ +/* + * Copyright 2020 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Performantly generate a unique, 30-char string by combining a version + * number, the current timestamp with a 13-digit number integer. + * @return {string} + */ +export const generateUniqueID = () => { + return `v4-${Date.now()}-${Math.floor(Math.random() * (9e12 - 1)) + 1e12}`; +}; diff --git a/frontend-old/node_modules/web-vitals/src/lib/getActivationStart.ts b/frontend-old/node_modules/web-vitals/src/lib/getActivationStart.ts new file mode 100644 index 0000000..3991c0e --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/getActivationStart.ts @@ -0,0 +1,22 @@ +/* + * Copyright 2022 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import {getNavigationEntry} from './getNavigationEntry.js'; + +export const getActivationStart = (): number => { + const navEntry = getNavigationEntry(); + return (navEntry && navEntry.activationStart) || 0; +}; diff --git a/frontend-old/node_modules/web-vitals/src/lib/getLoadState.ts b/frontend-old/node_modules/web-vitals/src/lib/getLoadState.ts new file mode 100644 index 0000000..788db0f --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/getLoadState.ts @@ -0,0 +1,51 @@ +/* + * Copyright 2022 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import {getNavigationEntry} from './getNavigationEntry.js'; +import {LoadState} from '../types.js'; + +export const getLoadState = (timestamp: number): LoadState => { + if (document.readyState === 'loading') { + // If the `readyState` is 'loading' there's no need to look at timestamps + // since the timestamp has to be the current time or earlier. + return 'loading'; + } else { + const navigationEntry = getNavigationEntry(); + if (navigationEntry) { + if (timestamp < navigationEntry.domInteractive) { + return 'loading'; + } else if ( + navigationEntry.domContentLoadedEventStart === 0 || + timestamp < navigationEntry.domContentLoadedEventStart + ) { + // If the `domContentLoadedEventStart` timestamp has not yet been + // set, or if the given timestamp is less than that value. + return 'dom-interactive'; + } else if ( + navigationEntry.domComplete === 0 || + timestamp < navigationEntry.domComplete + ) { + // If the `domComplete` timestamp has not yet been + // set, or if the given timestamp is less than that value. + return 'dom-content-loaded'; + } + } + } + // If any of the above fail, default to loaded. This could really only + // happy if the browser doesn't support the performance timeline, which + // most likely means this code would never run anyway. + return 'complete'; +}; diff --git a/frontend-old/node_modules/web-vitals/src/lib/getNavigationEntry.ts b/frontend-old/node_modules/web-vitals/src/lib/getNavigationEntry.ts new file mode 100644 index 0000000..19d18cf --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/getNavigationEntry.ts @@ -0,0 +1,37 @@ +/* + * Copyright 2022 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +export const getNavigationEntry = (): PerformanceNavigationTiming | void => { + const navigationEntry = + self.performance && + performance.getEntriesByType && + performance.getEntriesByType('navigation')[0]; + + // Check to ensure the `responseStart` property is present and valid. + // In some cases no value is reported by the browser (for + // privacy/security reasons), and in other cases (bugs) the value is + // negative or is larger than the current page time. Ignore these cases: + // https://github.com/GoogleChrome/web-vitals/issues/137 + // https://github.com/GoogleChrome/web-vitals/issues/162 + // https://github.com/GoogleChrome/web-vitals/issues/275 + if ( + navigationEntry && + navigationEntry.responseStart > 0 && + navigationEntry.responseStart < performance.now() + ) { + return navigationEntry; + } +}; diff --git a/frontend-old/node_modules/web-vitals/src/lib/getSelector.ts b/frontend-old/node_modules/web-vitals/src/lib/getSelector.ts new file mode 100644 index 0000000..4ca0bb9 --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/getSelector.ts @@ -0,0 +1,48 @@ +/* + * Copyright 2022 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +const getName = (node: Node) => { + const name = node.nodeName; + return node.nodeType === 1 + ? name.toLowerCase() + : name.toUpperCase().replace(/^#/, ''); +}; + +export const getSelector = (node: Node | null | undefined, maxLen?: number) => { + let sel = ''; + + try { + while (node && node.nodeType !== 9) { + const el: Element = node as Element; + const part = el.id + ? '#' + el.id + : getName(el) + + (el.classList && + el.classList.value && + el.classList.value.trim() && + el.classList.value.trim().length + ? '.' + el.classList.value.trim().replace(/\s+/g, '.') + : ''); + if (sel.length + part.length > (maxLen || 100) - 1) return sel || part; + sel = sel ? part + '>' + sel : part; + if (el.id) break; + node = el.parentNode; + } + } catch (err) { + // Do nothing... + } + return sel; +}; diff --git a/frontend-old/node_modules/web-vitals/src/lib/getVisibilityWatcher.ts b/frontend-old/node_modules/web-vitals/src/lib/getVisibilityWatcher.ts new file mode 100644 index 0000000..ad7b1c3 --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/getVisibilityWatcher.ts @@ -0,0 +1,89 @@ +/* + * Copyright 2020 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import {onBFCacheRestore} from './bfcache.js'; + +let firstHiddenTime = -1; + +const initHiddenTime = () => { + // If the document is hidden when this code runs, assume it was always + // hidden and the page was loaded in the background, with the one exception + // that visibility state is always 'hidden' during prerendering, so we have + // to ignore that case until prerendering finishes (see: `prerenderingchange` + // event logic below). + return document.visibilityState === 'hidden' && !document.prerendering + ? 0 + : Infinity; +}; + +const onVisibilityUpdate = (event: Event) => { + // If the document is 'hidden' and no previous hidden timestamp has been + // set, update it based on the current event data. + if (document.visibilityState === 'hidden' && firstHiddenTime > -1) { + // If the event is a 'visibilitychange' event, it means the page was + // visible prior to this change, so the event timestamp is the first + // hidden time. + // However, if the event is not a 'visibilitychange' event, then it must + // be a 'prerenderingchange' event, and the fact that the document is + // still 'hidden' from the above check means the tab was activated + // in a background state and so has always been hidden. + firstHiddenTime = event.type === 'visibilitychange' ? event.timeStamp : 0; + + // Remove all listeners now that a `firstHiddenTime` value has been set. + removeChangeListeners(); + } +}; + +const addChangeListeners = () => { + addEventListener('visibilitychange', onVisibilityUpdate, true); + // IMPORTANT: when a page is prerendering, its `visibilityState` is + // 'hidden', so in order to account for cases where this module checks for + // visibility during prerendering, an additional check after prerendering + // completes is also required. + addEventListener('prerenderingchange', onVisibilityUpdate, true); +}; + +const removeChangeListeners = () => { + removeEventListener('visibilitychange', onVisibilityUpdate, true); + removeEventListener('prerenderingchange', onVisibilityUpdate, true); +}; + +export const getVisibilityWatcher = () => { + if (firstHiddenTime < 0) { + // If the document is hidden when this code runs, assume it was hidden + // since navigation start. This isn't a perfect heuristic, but it's the + // best we can do until an API is available to support querying past + // visibilityState. + firstHiddenTime = initHiddenTime(); + addChangeListeners(); + + // Reset the time on bfcache restores. + onBFCacheRestore(() => { + // Schedule a task in order to track the `visibilityState` once it's + // had an opportunity to change to visible in all browsers. + // https://bugs.chromium.org/p/chromium/issues/detail?id=1133363 + setTimeout(() => { + firstHiddenTime = initHiddenTime(); + addChangeListeners(); + }, 0); + }); + } + return { + get firstHiddenTime() { + return firstHiddenTime; + }, + }; +}; diff --git a/frontend-old/node_modules/web-vitals/src/lib/initMetric.ts b/frontend-old/node_modules/web-vitals/src/lib/initMetric.ts new file mode 100644 index 0000000..90618d8 --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/initMetric.ts @@ -0,0 +1,57 @@ +/* + * Copyright 2020 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import {getBFCacheRestoreTime} from './bfcache.js'; +import {generateUniqueID} from './generateUniqueID.js'; +import {getActivationStart} from './getActivationStart.js'; +import {getNavigationEntry} from './getNavigationEntry.js'; +import {MetricType} from '../types.js'; + +export const initMetric = <MetricName extends MetricType['name']>( + name: MetricName, + value?: number, +) => { + const navEntry = getNavigationEntry(); + let navigationType: MetricType['navigationType'] = 'navigate'; + + if (getBFCacheRestoreTime() >= 0) { + navigationType = 'back-forward-cache'; + } else if (navEntry) { + if (document.prerendering || getActivationStart() > 0) { + navigationType = 'prerender'; + } else if (document.wasDiscarded) { + navigationType = 'restore'; + } else if (navEntry.type) { + navigationType = navEntry.type.replace( + /_/g, + '-', + ) as MetricType['navigationType']; + } + } + + // Use `entries` type specific for the metric. + const entries: Extract<MetricType, {name: MetricName}>['entries'] = []; + + return { + name, + value: typeof value === 'undefined' ? -1 : value, + rating: 'good' as const, // If needed, will be updated when reported. `const` to keep the type from widening to `string`. + delta: 0, + entries, + id: generateUniqueID(), + navigationType, + }; +}; diff --git a/frontend-old/node_modules/web-vitals/src/lib/interactions.ts b/frontend-old/node_modules/web-vitals/src/lib/interactions.ts new file mode 100644 index 0000000..fbd0751 --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/interactions.ts @@ -0,0 +1,139 @@ +/* + * Copyright 2024 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import {getInteractionCount} from './polyfills/interactionCountPolyfill.js'; + +interface Interaction { + id: number; + latency: number; + entries: PerformanceEventTiming[]; +} + +interface EntryPreProcessingHook { + (entry: PerformanceEventTiming): void; +} + +// A list of longest interactions on the page (by latency) sorted so the +// longest one is first. The list is at most MAX_INTERACTIONS_TO_CONSIDER long. +export const longestInteractionList: Interaction[] = []; + +// A mapping of longest interactions by their interaction ID. +// This is used for faster lookup. +export const longestInteractionMap: Map<number, Interaction> = new Map(); + +// The default `durationThreshold` used across this library for observing +// `event` entries via PerformanceObserver. +export const DEFAULT_DURATION_THRESHOLD = 40; + +// Used to store the interaction count after a bfcache restore, since p98 +// interaction latencies should only consider the current navigation. +let prevInteractionCount = 0; + +/** + * Returns the interaction count since the last bfcache restore (or for the + * full page lifecycle if there were no bfcache restores). + */ +const getInteractionCountForNavigation = () => { + return getInteractionCount() - prevInteractionCount; +}; + +export const resetInteractions = () => { + prevInteractionCount = getInteractionCount(); + longestInteractionList.length = 0; + longestInteractionMap.clear(); +}; + +/** + * Returns the estimated p98 longest interaction based on the stored + * interaction candidates and the interaction count for the current page. + */ +export const estimateP98LongestInteraction = () => { + const candidateInteractionIndex = Math.min( + longestInteractionList.length - 1, + Math.floor(getInteractionCountForNavigation() / 50), + ); + + return longestInteractionList[candidateInteractionIndex]; +}; + +// To prevent unnecessary memory usage on pages with lots of interactions, +// store at most 10 of the longest interactions to consider as INP candidates. +const MAX_INTERACTIONS_TO_CONSIDER = 10; + +/** + * A list of callback functions to run before each entry is processed. + * Exposing this list allows the attribution build to hook into the + * entry processing pipeline. + */ +export const entryPreProcessingCallbacks: EntryPreProcessingHook[] = []; + +/** + * Takes a performance entry and adds it to the list of worst interactions + * if its duration is long enough to make it among the worst. If the + * entry is part of an existing interaction, it is merged and the latency + * and entries list is updated as needed. + */ +export const processInteractionEntry = (entry: PerformanceEventTiming) => { + entryPreProcessingCallbacks.forEach((cb) => cb(entry)); + + // Skip further processing for entries that cannot be INP candidates. + if (!(entry.interactionId || entry.entryType === 'first-input')) return; + + // The least-long of the 10 longest interactions. + const minLongestInteraction = + longestInteractionList[longestInteractionList.length - 1]; + + const existingInteraction = longestInteractionMap.get(entry.interactionId!); + + // Only process the entry if it's possibly one of the ten longest, + // or if it's part of an existing interaction. + if ( + existingInteraction || + longestInteractionList.length < MAX_INTERACTIONS_TO_CONSIDER || + entry.duration > minLongestInteraction.latency + ) { + // If the interaction already exists, update it. Otherwise create one. + if (existingInteraction) { + // If the new entry has a longer duration, replace the old entries, + // otherwise add to the array. + if (entry.duration > existingInteraction.latency) { + existingInteraction.entries = [entry]; + existingInteraction.latency = entry.duration; + } else if ( + entry.duration === existingInteraction.latency && + entry.startTime === existingInteraction.entries[0].startTime + ) { + existingInteraction.entries.push(entry); + } + } else { + const interaction = { + id: entry.interactionId!, + latency: entry.duration, + entries: [entry], + }; + longestInteractionMap.set(interaction.id, interaction); + longestInteractionList.push(interaction); + } + + // Sort the entries by latency (descending) and keep only the top ten. + longestInteractionList.sort((a, b) => b.latency - a.latency); + if (longestInteractionList.length > MAX_INTERACTIONS_TO_CONSIDER) { + longestInteractionList + .splice(MAX_INTERACTIONS_TO_CONSIDER) + .forEach((i) => longestInteractionMap.delete(i.id)); + } + } +}; diff --git a/frontend-old/node_modules/web-vitals/src/lib/observe.ts b/frontend-old/node_modules/web-vitals/src/lib/observe.ts new file mode 100644 index 0000000..f3127a3 --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/observe.ts @@ -0,0 +1,66 @@ +/* + * Copyright 2020 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +interface PerformanceEntryMap { + 'event': PerformanceEventTiming[]; + 'first-input': PerformanceEventTiming[]; + 'layout-shift': LayoutShift[]; + 'largest-contentful-paint': LargestContentfulPaint[]; + 'long-animation-frame': PerformanceLongAnimationFrameTiming[]; + 'paint': PerformancePaintTiming[]; + 'navigation': PerformanceNavigationTiming[]; + 'resource': PerformanceResourceTiming[]; +} + +/** + * Takes a performance entry type and a callback function, and creates a + * `PerformanceObserver` instance that will observe the specified entry type + * with buffering enabled and call the callback _for each entry_. + * + * This function also feature-detects entry support and wraps the logic in a + * try/catch to avoid errors in unsupporting browsers. + */ +export const observe = <K extends keyof PerformanceEntryMap>( + type: K, + callback: (entries: PerformanceEntryMap[K]) => void, + opts?: PerformanceObserverInit, +): PerformanceObserver | undefined => { + try { + if (PerformanceObserver.supportedEntryTypes.includes(type)) { + const po = new PerformanceObserver((list) => { + // Delay by a microtask to workaround a bug in Safari where the + // callback is invoked immediately, rather than in a separate task. + // See: https://github.com/GoogleChrome/web-vitals/issues/277 + Promise.resolve().then(() => { + callback(list.getEntries() as PerformanceEntryMap[K]); + }); + }); + po.observe( + Object.assign( + { + type, + buffered: true, + }, + opts || {}, + ) as PerformanceObserverInit, + ); + return po; + } + } catch (e) { + // Do nothing. + } + return; +}; diff --git a/frontend-old/node_modules/web-vitals/src/lib/onHidden.ts b/frontend-old/node_modules/web-vitals/src/lib/onHidden.ts new file mode 100644 index 0000000..f59d4c9 --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/onHidden.ts @@ -0,0 +1,23 @@ +/* + * Copyright 2020 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +export const onHidden = (cb: () => void) => { + document.addEventListener('visibilitychange', () => { + if (document.visibilityState === 'hidden') { + cb(); + } + }); +}; diff --git a/frontend-old/node_modules/web-vitals/src/lib/polyfills/firstInputPolyfill.ts b/frontend-old/node_modules/web-vitals/src/lib/polyfills/firstInputPolyfill.ts new file mode 100644 index 0000000..804c423 --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/polyfills/firstInputPolyfill.ts @@ -0,0 +1,174 @@ +/* + * Copyright 2020 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { + FirstInputPolyfillEntry, + FirstInputPolyfillCallback, +} from '../../types.js'; + +type addOrRemoveEventListener = + | typeof addEventListener + | typeof removeEventListener; + +let firstInputEvent: Event | null; +let firstInputDelay: number; +let firstInputTimeStamp: Date; +let callbacks: FirstInputPolyfillCallback[]; + +const listenerOpts: AddEventListenerOptions = {passive: true, capture: true}; +const startTimeStamp: Date = new Date(); + +/** + * Accepts a callback to be invoked once the first input delay and event + * are known. + */ +export const firstInputPolyfill = ( + onFirstInput: FirstInputPolyfillCallback, +) => { + callbacks.push(onFirstInput); + reportFirstInputDelayIfRecordedAndValid(); +}; + +export const resetFirstInputPolyfill = () => { + callbacks = []; + firstInputDelay = -1; + firstInputEvent = null; + eachEventType(addEventListener); +}; + +/** + * Records the first input delay and event, so subsequent events can be + * ignored. All added event listeners are then removed. + */ +const recordFirstInputDelay = (delay: number, event: Event) => { + if (!firstInputEvent) { + firstInputEvent = event; + firstInputDelay = delay; + firstInputTimeStamp = new Date(); + + eachEventType(removeEventListener); + reportFirstInputDelayIfRecordedAndValid(); + } +}; + +/** + * Reports the first input delay and event (if they're recorded and valid) + * by running the array of callback functions. + */ +const reportFirstInputDelayIfRecordedAndValid = () => { + // In some cases the recorded delay is clearly wrong, e.g. it's negative + // or it's larger than the delta between now and initialization. + // - https://github.com/GoogleChromeLabs/first-input-delay/issues/4 + // - https://github.com/GoogleChromeLabs/first-input-delay/issues/6 + // - https://github.com/GoogleChromeLabs/first-input-delay/issues/7 + if ( + firstInputDelay >= 0 && + // @ts-ignore (subtracting two dates always returns a number) + firstInputDelay < firstInputTimeStamp - startTimeStamp + ) { + const entry = { + entryType: 'first-input', + name: firstInputEvent!.type, + target: firstInputEvent!.target, + cancelable: firstInputEvent!.cancelable, + startTime: firstInputEvent!.timeStamp, + processingStart: firstInputEvent!.timeStamp + firstInputDelay, + } as FirstInputPolyfillEntry; + callbacks.forEach(function (callback) { + callback(entry); + }); + callbacks = []; + } +}; + +/** + * Handles pointer down events, which are a special case. + * Pointer events can trigger main or compositor thread behavior. + * We differentiate these cases based on whether or not we see a + * 'pointercancel' event, which are fired when we scroll. If we're scrolling + * we don't need to report input delay since FID excludes scrolling and + * pinch/zooming. + */ +const onPointerDown = (delay: number, event: Event) => { + /** + * Responds to 'pointerup' events and records a delay. If a pointer up event + * is the next event after a pointerdown event, then it's not a scroll or + * a pinch/zoom. + */ + const onPointerUp = () => { + recordFirstInputDelay(delay, event); + removePointerEventListeners(); + }; + + /** + * Responds to 'pointercancel' events and removes pointer listeners. + * If a 'pointercancel' is the next event to fire after a pointerdown event, + * it means this is a scroll or pinch/zoom interaction. + */ + const onPointerCancel = () => { + removePointerEventListeners(); + }; + + /** + * Removes added pointer event listeners. + */ + const removePointerEventListeners = () => { + removeEventListener('pointerup', onPointerUp, listenerOpts); + removeEventListener('pointercancel', onPointerCancel, listenerOpts); + }; + + addEventListener('pointerup', onPointerUp, listenerOpts); + addEventListener('pointercancel', onPointerCancel, listenerOpts); +}; + +/** + * Handles all input events and records the time between when the event + * was received by the operating system and when it's JavaScript listeners + * were able to run. + */ +const onInput = (event: Event) => { + // Only count cancelable events, which should trigger behavior + // important to the user. + if (event.cancelable) { + // In some browsers `event.timeStamp` returns a `DOMTimeStamp` value + // (epoch time) instead of the newer `DOMHighResTimeStamp` + // (document-origin time). To check for that we assume any timestamp + // greater than 1 trillion is a `DOMTimeStamp`, and compare it using + // the `Date` object rather than `performance.now()`. + // - https://github.com/GoogleChromeLabs/first-input-delay/issues/4 + const isEpochTime = event.timeStamp > 1e12; + const now = isEpochTime ? new Date() : performance.now(); + + // Input delay is the delta between when the system received the event + // (e.g. event.timeStamp) and when it could run the callback (e.g. `now`). + const delay = (now as number) - event.timeStamp; + + if (event.type == 'pointerdown') { + onPointerDown(delay, event); + } else { + recordFirstInputDelay(delay, event); + } + } +}; + +/** + * Invokes the passed callback const for = each event type with t =>he + * `onInput` const and = `listenerOpts =>`. + */ +const eachEventType = (callback: addOrRemoveEventListener) => { + const eventTypes = ['mousedown', 'keydown', 'touchstart', 'pointerdown']; + eventTypes.forEach((type) => callback(type, onInput, listenerOpts)); +}; diff --git a/frontend-old/node_modules/web-vitals/src/lib/polyfills/getFirstHiddenTimePolyfill.ts b/frontend-old/node_modules/web-vitals/src/lib/polyfills/getFirstHiddenTimePolyfill.ts new file mode 100644 index 0000000..9d7f26a --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/polyfills/getFirstHiddenTimePolyfill.ts @@ -0,0 +1,29 @@ +/* + * Copyright 2020 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +let firstHiddenTime = document.visibilityState === 'hidden' ? 0 : Infinity; + +const onVisibilityChange = (event: Event) => { + if (document.visibilityState === 'hidden') { + firstHiddenTime = event.timeStamp; + removeEventListener('visibilitychange', onVisibilityChange, true); + } +}; + +// Note: do not add event listeners unconditionally (outside of polyfills). +addEventListener('visibilitychange', onVisibilityChange, true); + +export const getFirstHiddenTime = () => firstHiddenTime; diff --git a/frontend-old/node_modules/web-vitals/src/lib/polyfills/interactionCountPolyfill.ts b/frontend-old/node_modules/web-vitals/src/lib/polyfills/interactionCountPolyfill.ts new file mode 100644 index 0000000..e363376 --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/polyfills/interactionCountPolyfill.ts @@ -0,0 +1,63 @@ +/* + * Copyright 2022 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import {observe} from '../observe.js'; + +declare global { + interface Performance { + interactionCount: number; + } +} + +let interactionCountEstimate = 0; +let minKnownInteractionId = Infinity; +let maxKnownInteractionId = 0; + +const updateEstimate = (entries: PerformanceEventTiming[]) => { + entries.forEach((e) => { + if (e.interactionId) { + minKnownInteractionId = Math.min(minKnownInteractionId, e.interactionId); + maxKnownInteractionId = Math.max(maxKnownInteractionId, e.interactionId); + + interactionCountEstimate = maxKnownInteractionId + ? (maxKnownInteractionId - minKnownInteractionId) / 7 + 1 + : 0; + } + }); +}; + +let po: PerformanceObserver | undefined; + +/** + * Returns the `interactionCount` value using the native API (if available) + * or the polyfill estimate in this module. + */ +export const getInteractionCount = () => { + return po ? interactionCountEstimate : performance.interactionCount || 0; +}; + +/** + * Feature detects native support or initializes the polyfill if needed. + */ +export const initInteractionCountPolyfill = () => { + if ('interactionCount' in performance || po) return; + + po = observe('event', updateEstimate, { + type: 'event', + buffered: true, + durationThreshold: 0, + } as PerformanceObserverInit); +}; diff --git a/frontend-old/node_modules/web-vitals/src/lib/runOnce.ts b/frontend-old/node_modules/web-vitals/src/lib/runOnce.ts new file mode 100644 index 0000000..f2de2ea --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/runOnce.ts @@ -0,0 +1,25 @@ +/* + * Copyright 2022 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +export const runOnce = (cb: () => void) => { + let called = false; + return () => { + if (!called) { + cb(); + called = true; + } + }; +}; diff --git a/frontend-old/node_modules/web-vitals/src/lib/whenActivated.ts b/frontend-old/node_modules/web-vitals/src/lib/whenActivated.ts new file mode 100644 index 0000000..e4046c9 --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/whenActivated.ts @@ -0,0 +1,23 @@ +/* + * Copyright 2022 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +export const whenActivated = (callback: () => void) => { + if (document.prerendering) { + addEventListener('prerenderingchange', () => callback(), true); + } else { + callback(); + } +}; diff --git a/frontend-old/node_modules/web-vitals/src/lib/whenIdle.ts b/frontend-old/node_modules/web-vitals/src/lib/whenIdle.ts new file mode 100644 index 0000000..9abb30c --- /dev/null +++ b/frontend-old/node_modules/web-vitals/src/lib/whenIdle.ts @@ -0,0 +1,38 @@ +/* + * Copyright 2024 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import {onHidden} from './onHidden.js'; +import {runOnce} from './runOnce.js'; + +/** + * Runs the passed callback during the next idle period, or immediately + * if the browser's visibility state is (or becomes) hidden. + */ +export const whenIdle = (cb: () => void): number => { + const rIC = self.requestIdleCallback || self.setTimeout; + + let handle = -1; + cb = runOnce(cb); + // If the document is hidden, run the callback immediately, otherwise + // race an idle callback with the next `visibilitychange` event. + if (document.visibilityState === 'hidden') { + cb(); + } else { + handle = rIC(cb); + onHidden(cb); + } + return handle; +}; |