FM / components

/opt/canhelp/node_modules/next/dist/client/components/

/opt/canhelp/node_modules/next/dist/client/components

Name	Size	Mode	Actions
builtin/	-	0755	rm
errors/	-	0755	rm
http-access-fallback/	-	0755	rm
metadata/	-	0755	rm
router-reducer/	-	0755	rm
segment-cache-impl/	-	0755	rm
styles/	-	0755	rm
app-router-announcer.d.ts	196	0644	edit dl rm
app-router-announcer.js	3352	0644	edit dl rm
app-router-announcer.js.map	4678	0644	edit dl rm
app-router-headers.d.ts	1243	0644	edit dl rm
app-router-headers.js	3797	0644	edit dl rm
app-router-headers.js.map	3110	0644	edit dl rm
app-router-instance.d.ts	2081	0644	edit dl rm
app-router-instance.js	14432	0644	edit dl rm
app-router-instance.js.map	21179	0644	edit dl rm
app-router.d.ts	932	0644	edit dl rm
app-router.js	24987	0644	edit dl rm
app-router.js.map	34863	0644	edit dl rm
bailout-to-client-rendering.d.ts	80	0644	edit dl rm
bailout-to-client-rendering.js	1877	0644	edit dl rm
bailout-to-client-rendering.js.map	1665	0644	edit dl rm
bfcache.d.ts	1397	0644	edit dl rm
bfcache.js	4035	0644	edit dl rm
bfcache.js.map	6376	0644	edit dl rm
client-page.d.ts	876	0644	edit dl rm
client-page.js	2603	0644	edit dl rm
client-page.js.map	3907	0644	edit dl rm
client-segment.d.ts	842	0644	edit dl rm
client-segment.js	2192	0644	edit dl rm
client-segment.js.map	3087	0644	edit dl rm
dev-root-http-access-fallback-boundary.d.ts	230	0644	edit dl rm
dev-root-http-access-fallback-boundary.js	1862	0644	edit dl rm
dev-root-http-access-fallback-boundary.js.map	1290	0644	edit dl rm
error-boundary.d.ts	1566	0644	edit dl rm
error-boundary.js	5499	0644	edit dl rm
error-boundary.js.map	7409	0644	edit dl rm
forbidden.d.ts	44	0644	edit dl rm
forbidden.js	2077	0644	edit dl rm
forbidden.js.map	1986	0644	edit dl rm
handle-isr-error.d.ts	78	0644	edit dl rm
handle-isr-error.js	1085	0644	edit dl rm
handle-isr-error.js.map	1295	0644	edit dl rm
hooks-server-context.d.ts	326	0644	edit dl rm
hooks-server-context.js	1352	0644	edit dl rm
hooks-server-context.js.map	1182	0644	edit dl rm
is-next-router-error.d.ts	431	0644	edit dl rm
is-next-router-error.js	886	0644	edit dl rm
is-next-router-error.js.map	899	0644	edit dl rm
layout-router.d.ts	999	0644	edit dl rm
layout-router.js	27947	0644	edit dl rm
layout-router.js.map	37701	0644	edit dl rm
links.d.ts	2241	0644	edit dl rm
links.js	14053	0644	edit dl rm
links.js.map	21056	0644	edit dl rm
match-segments.d.ts	154	0644	edit dl rm
match-segments.js	1054	0644	edit dl rm
match-segments.js.map	1045	0644	edit dl rm
nav-failure-handler.d.ts	123	0644	edit dl rm
nav-failure-handler.js	2492	0644	edit dl rm
nav-failure-handler.js.map	2868	0644	edit dl rm
navigation-untracked.d.ts	11	0644	edit dl rm
navigation-untracked.js	2607	0644	edit dl rm
navigation-untracked.js.map	3349	0644	edit dl rm
navigation.d.ts	4635	0644	edit dl rm
navigation.js	7942	0644	edit dl rm
navigation.js.map	12713	0644	edit dl rm
navigation.react-server.d.ts	1238	0644	edit dl rm
navigation.react-server.js	3501	0644	edit dl rm
navigation.react-server.js.map	2838	0644	edit dl rm
noop-head.d.ts	42	0644	edit dl rm
noop-head.js	607	0644	edit dl rm
noop-head.js.map	249	0644	edit dl rm
not-found.d.ts	43	0644	edit dl rm
not-found.js	1888	0644	edit dl rm
not-found.js.map	1750	0644	edit dl rm
promise-queue.d.ts	192	0644	edit dl rm
promise-queue.js	4274	0644	edit dl rm
promise-queue.js.map	3607	0644	edit dl rm
redirect-boundary.d.ts	776	0644	edit dl rm
redirect-boundary.js	3270	0644	edit dl rm
redirect-boundary.js.map	3975	0644	edit dl rm
redirect-error.d.ts	633	0644	edit dl rm
redirect-error.js	1819	0644	edit dl rm
redirect-error.js.map	2124	0644	edit dl rm
redirect-status-code.d.ts	120	0644	edit dl rm
redirect-status-code.js	967	0644	edit dl rm
redirect-status-code.js.map	330	0644	edit dl rm
redirect.d.ts	2469	0644	edit dl rm
redirect.js	3746	0644	edit dl rm
redirect.js.map	5919	0644	edit dl rm
render-from-template-context.d.ts	100	0644	edit dl rm
render-from-template-context.js	1170	0644	edit dl rm
render-from-template-context.js.map	645	0644	edit dl rm
segment-cache.d.ts	3498	0644	edit dl rm
segment-cache.js	7611	0644	edit dl rm
segment-cache.js.map	8946	0644	edit dl rm
static-generation-bailout.d.ts	205	0644	edit dl rm
static-generation-bailout.js	1302	0644	edit dl rm
static-generation-bailout.js.map	926	0644	edit dl rm
unauthorized.d.ts	47	0644	edit dl rm
unauthorized.js	2110	0644	edit dl rm
unauthorized.js.map	2018	0644	edit dl rm
unrecognized-action-error.d.ts	790	0644	edit dl rm
unrecognized-action-error.js	1244	0644	edit dl rm
unrecognized-action-error.js.map	1502	0644	edit dl rm
unresolved-thenable.d.ts	183	0644	edit dl rm
unresolved-thenable.js	769	0644	edit dl rm
unresolved-thenable.js.map	450	0644	edit dl rm
unstable-rethrow.browser.d.ts	64	0644	edit dl rm
unstable-rethrow.browser.js	1011	0644	edit dl rm
unstable-rethrow.browser.js.map	832	0644	edit dl rm
unstable-rethrow.d.ts	591	0644	edit dl rm
unstable-rethrow.js	1250	0644	edit dl rm
unstable-rethrow.js.map	1122	0644	edit dl rm
unstable-rethrow.server.d.ts	64	0644	edit dl rm
unstable-rethrow.server.js	1521	0644	edit dl rm
unstable-rethrow.server.js.map	1505	0644	edit dl rm
use-action-queue.d.ts	330	0644	edit dl rm
use-action-queue.js	2903	0644	edit dl rm
use-action-queue.js.map	3300	0644	edit dl rm

Edit: /opt/canhelp/node_modules/next/dist/client/components/links.js (14053B)

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
0 && (module.exports = {
    IDLE_LINK_STATUS: null,
    PENDING_LINK_STATUS: null,
    mountFormInstance: null,
    mountLinkInstance: null,
    onLinkVisibilityChanged: null,
    onNavigationIntent: null,
    pingVisibleLinks: null,
    setLinkForCurrentNavigation: null,
    unmountLinkForCurrentNavigation: null,
    unmountPrefetchableInstance: null
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: all[name]
    });
}
_export(exports, {
    IDLE_LINK_STATUS: function() {
        return IDLE_LINK_STATUS;
    },
    PENDING_LINK_STATUS: function() {
        return PENDING_LINK_STATUS;
    },
    mountFormInstance: function() {
        return mountFormInstance;
    },
    mountLinkInstance: function() {
        return mountLinkInstance;
    },
    onLinkVisibilityChanged: function() {
        return onLinkVisibilityChanged;
    },
    onNavigationIntent: function() {
        return onNavigationIntent;
    },
    pingVisibleLinks: function() {
        return pingVisibleLinks;
    },
    setLinkForCurrentNavigation: function() {
        return setLinkForCurrentNavigation;
    },
    unmountLinkForCurrentNavigation: function() {
        return unmountLinkForCurrentNavigation;
    },
    unmountPrefetchableInstance: function() {
        return unmountPrefetchableInstance;
    }
});
const _approuterinstance = require("./app-router-instance");
const _approuter = require("./app-router");
const _segmentcache = require("./segment-cache");
const _react = require("react");
const _routerreducertypes = require("./router-reducer/router-reducer-types");
const _invarianterror = require("../../shared/lib/invariant-error");
// Tracks the most recently navigated link instance. When null, indicates
// the current navigation was not initiated by a link click.
let linkForMostRecentNavigation = null;
const PENDING_LINK_STATUS = {
    pending: true
};
const IDLE_LINK_STATUS = {
    pending: false
};
function setLinkForCurrentNavigation(link) {
    (0, _react.startTransition)(()=>{
        linkForMostRecentNavigation == null ? void 0 : linkForMostRecentNavigation.setOptimisticLinkStatus(IDLE_LINK_STATUS);
        link == null ? void 0 : link.setOptimisticLinkStatus(PENDING_LINK_STATUS);
        linkForMostRecentNavigation = link;
    });
}
function unmountLinkForCurrentNavigation(link) {
    if (linkForMostRecentNavigation === link) {
        linkForMostRecentNavigation = null;
    }
}
// Use a WeakMap to associate a Link instance with its DOM element. This is
// used by the IntersectionObserver to track the link's visibility.
const prefetchable = typeof WeakMap === 'function' ? new WeakMap() : new Map();
// A Set of the currently visible links. We re-prefetch visible links after a
// cache invalidation, or when the current URL changes. It's a separate data
// structure from the WeakMap above because only the visible links need to
// be enumerated.
const prefetchableAndVisible = new Set();
// A single IntersectionObserver instance shared by all <Link> components.
const observer = typeof IntersectionObserver === 'function' ? new IntersectionObserver(handleIntersect, {
    rootMargin: '200px'
}) : null;
function observeVisibility(element, instance) {
    const existingInstance = prefetchable.get(element);
    if (existingInstance !== undefined) {
        // This shouldn't happen because each <Link> component should have its own
        // anchor tag instance, but it's defensive coding to avoid a memory leak in
        // case there's a logical error somewhere else.
        unmountPrefetchableInstance(element);
    }
    // Only track prefetchable links that have a valid prefetch URL
    prefetchable.set(element, instance);
    if (observer !== null) {
        observer.observe(element);
    }
}
function coercePrefetchableUrl(href) {
    try {
        return (0, _approuter.createPrefetchURL)(href);
    } catch (e) {
        // createPrefetchURL sometimes throws an error if an invalid URL is
        // provided, though I'm not sure if it's actually necessary.
        // TODO: Consider removing the throw from the inner function, or change it
        // to reportError. Or maybe the error isn't even necessary for automatic
        // prefetches, just navigations.
        const reportErrorFn = typeof reportError === 'function' ? reportError : console.error;
        reportErrorFn("Cannot prefetch '" + href + "' because it cannot be converted to a URL.");
        return null;
    }
}
function mountLinkInstance(element, href, router, fetchStrategy, prefetchEnabled, setOptimisticLinkStatus) {
    if (prefetchEnabled) {
        const prefetchURL = coercePrefetchableUrl(href);
        if (prefetchURL !== null) {
            const instance = {
                router,
                fetchStrategy,
                isVisible: false,
                prefetchTask: null,
                prefetchHref: prefetchURL.href,
                setOptimisticLinkStatus
            };
            // We only observe the link's visibility if it's prefetchable. For
            // example, this excludes links to external URLs.
            observeVisibility(element, instance);
            return instance;
        }
    }
    // If the link is not prefetchable, we still create an instance so we can
    // track its optimistic state (i.e. useLinkStatus).
    const instance = {
        router,
        fetchStrategy,
        isVisible: false,
        prefetchTask: null,
        prefetchHref: null,
        setOptimisticLinkStatus
    };
    return instance;
}
function mountFormInstance(element, href, router, fetchStrategy) {
    const prefetchURL = coercePrefetchableUrl(href);
    if (prefetchURL === null) {
        // This href is not prefetchable, so we don't track it.
        // TODO: We currently observe/unobserve a form every time its href changes.
        // For Links, this isn't a big deal because the href doesn't usually change,
        // but for forms it's extremely common. We should optimize this.
        return;
    }
    const instance = {
        router,
        fetchStrategy,
        isVisible: false,
        prefetchTask: null,
        prefetchHref: prefetchURL.href,
        setOptimisticLinkStatus: null
    };
    observeVisibility(element, instance);
}
function unmountPrefetchableInstance(element) {
    const instance = prefetchable.get(element);
    if (instance !== undefined) {
        prefetchable.delete(element);
        prefetchableAndVisible.delete(instance);
        const prefetchTask = instance.prefetchTask;
        if (prefetchTask !== null) {
            (0, _segmentcache.cancelPrefetchTask)(prefetchTask);
        }
    }
    if (observer !== null) {
        observer.unobserve(element);
    }
}
function handleIntersect(entries) {
    for (const entry of entries){
        // Some extremely old browsers or polyfills don't reliably support
        // isIntersecting so we check intersectionRatio instead. (Do we care? Not
        // really. But whatever this is fine.)
        const isVisible = entry.intersectionRatio > 0;
        onLinkVisibilityChanged(entry.target, isVisible);
    }
}
function onLinkVisibilityChanged(element, isVisible) {
    if (process.env.NODE_ENV !== 'production') {
        // Prefetching on viewport is disabled in development for performance
        // reasons, because it requires compiling the target page.
        // TODO: Investigate re-enabling this.
        return;
    }
    const instance = prefetchable.get(element);
    if (instance === undefined) {
        return;
    }
    instance.isVisible = isVisible;
    if (isVisible) {
        prefetchableAndVisible.add(instance);
    } else {
        prefetchableAndVisible.delete(instance);
    }
    rescheduleLinkPrefetch(instance, _segmentcache.PrefetchPriority.Default);
}
function onNavigationIntent(element, unstable_upgradeToDynamicPrefetch) {
    const instance = prefetchable.get(element);
    if (instance === undefined) {
        return;
    }
    // Prefetch the link on hover/touchstart.
    if (instance !== undefined) {
        if (process.env.__NEXT_DYNAMIC_ON_HOVER && unstable_upgradeToDynamicPrefetch) {
            // Switch to a full prefetch
            instance.fetchStrategy = _segmentcache.FetchStrategy.Full;
        }
        rescheduleLinkPrefetch(instance, _segmentcache.PrefetchPriority.Intent);
    }
}
function rescheduleLinkPrefetch(instance, priority) {
    const existingPrefetchTask = instance.prefetchTask;
    if (!instance.isVisible) {
        // Cancel any in-progress prefetch task. (If it already finished then this
        // is a no-op.)
        if (existingPrefetchTask !== null) {
            (0, _segmentcache.cancelPrefetchTask)(existingPrefetchTask);
        }
        // We don't need to reset the prefetchTask to null upon cancellation; an
        // old task object can be rescheduled with reschedulePrefetchTask. This is a
        // micro-optimization but also makes the code simpler (don't need to
        // worry about whether an old task object is stale).
        return;
    }
    if (!process.env.__NEXT_CLIENT_SEGMENT_CACHE) {
        // The old prefetch implementation does not have different priority levels.
        // Just schedule a new prefetch task.
        prefetchWithOldCacheImplementation(instance);
        return;
    }
    const appRouterState = (0, _approuterinstance.getCurrentAppRouterState)();
    if (appRouterState !== null) {
        const treeAtTimeOfPrefetch = appRouterState.tree;
        if (existingPrefetchTask === null) {
            // Initiate a prefetch task.
            const nextUrl = appRouterState.nextUrl;
            const cacheKey = (0, _segmentcache.createCacheKey)(instance.prefetchHref, nextUrl);
            instance.prefetchTask = (0, _segmentcache.schedulePrefetchTask)(cacheKey, treeAtTimeOfPrefetch, instance.fetchStrategy, priority, null);
        } else {
            // We already have an old task object that we can reschedule. This is
            // effectively the same as canceling the old task and creating a new one.
            (0, _segmentcache.reschedulePrefetchTask)(existingPrefetchTask, treeAtTimeOfPrefetch, instance.fetchStrategy, priority);
        }
    }
}
function pingVisibleLinks(nextUrl, tree) {
    // For each currently visible link, cancel the existing prefetch task (if it
    // exists) and schedule a new one. This is effectively the same as if all the
    // visible links left and then re-entered the viewport.
    //
    // This is called when the Next-Url or the base tree changes, since those
    // may affect the result of a prefetch task. It's also called after a
    // cache invalidation.
    for (const instance of prefetchableAndVisible){
        const task = instance.prefetchTask;
        if (task !== null && !(0, _segmentcache.isPrefetchTaskDirty)(task, nextUrl, tree)) {
            continue;
        }
        // Something changed. Cancel the existing prefetch task and schedule a
        // new one.
        if (task !== null) {
            (0, _segmentcache.cancelPrefetchTask)(task);
        }
        const cacheKey = (0, _segmentcache.createCacheKey)(instance.prefetchHref, nextUrl);
        instance.prefetchTask = (0, _segmentcache.schedulePrefetchTask)(cacheKey, tree, instance.fetchStrategy, _segmentcache.PrefetchPriority.Default, null);
    }
}
function prefetchWithOldCacheImplementation(instance) {
    // This is the path used when the Segment Cache is not enabled.
    if (typeof window === 'undefined') {
        return;
    }
    const doPrefetch = async ()=>{
        // note that `appRouter.prefetch()` is currently sync,
        // so we have to wrap this call in an async function to be able to catch() errors below.
        let prefetchKind;
        switch(instance.fetchStrategy){
            case _segmentcache.FetchStrategy.PPR:
                {
                    prefetchKind = _routerreducertypes.PrefetchKind.AUTO;
                    break;
                }
            case _segmentcache.FetchStrategy.Full:
                {
                    prefetchKind = _routerreducertypes.PrefetchKind.FULL;
                    break;
                }
            case _segmentcache.FetchStrategy.PPRRuntime:
                {
                    // We can only get here if Client Segment Cache is off, and in that case
                    // it shouldn't be possible for a link to request a runtime prefetch.
                    throw Object.defineProperty(new _invarianterror.InvariantError('FetchStrategy.PPRRuntime should never be used when `experimental.clientSegmentCache` is disabled'), "__NEXT_ERROR_CODE", {
                        value: "E772",
                        enumerable: false,
                        configurable: true
                    });
                }
            default:
                {
                    instance.fetchStrategy;
                    // Unreachable, but otherwise typescript will consider the variable unassigned
                    prefetchKind = undefined;
                }
        }
        return instance.router.prefetch(instance.prefetchHref, {
            kind: prefetchKind
        });
    };
    // Prefetch the page if asked (only in the client)
    // We need to handle a prefetch error here since we may be
    // loading with priority which can reject but we don't
    // want to force navigation since this is only a prefetch
    doPrefetch().catch((err)=>{
        if (process.env.NODE_ENV !== 'production') {
            // rethrow to show invalid URL errors
            throw err;
        }
    });
}

if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
  Object.defineProperty(exports.default, '__esModule', { value: true });
  Object.assign(exports.default, exports);
  module.exports = exports.default;
}

//# sourceMappingURL=links.js.map

cmd: