inital commit

node_modules/next/dist/esm/client/app-dir/form.js

@@ -0,0 +1,142 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useContext } from 'react';
+import { addBasePath } from '../add-base-path';
+import { useMergedRef } from '../use-merged-ref';
+import { AppRouterContext } from '../../shared/lib/app-router-context.shared-runtime';
+import { PrefetchKind } from '../components/router-reducer/router-reducer-types';
+import { checkFormActionUrl, createFormSubmitDestinationUrl, DISALLOWED_FORM_PROPS, hasReactClientActionAttributes, hasUnsupportedSubmitterAttributes } from '../form-shared';
+import { mountLinkInstance, unmountLinkInstance } from '../components/links';
+export default function Form(param) {
+    let { replace, scroll, prefetch: prefetchProp, ref: externalRef, ...props } = param;
+    const router = useContext(AppRouterContext);
+    const actionProp = props.action;
+    const isNavigatingForm = typeof actionProp === 'string';
+    // Validate `action`
+    if (process.env.NODE_ENV === 'development') {
+        if (isNavigatingForm) {
+            checkFormActionUrl(actionProp, 'action');
+        }
+    }
+    // Validate `prefetch`
+    if (process.env.NODE_ENV === 'development') {
+        if (!(prefetchProp === undefined || prefetchProp === false || prefetchProp === null)) {
+            console.error('The `prefetch` prop of <Form> must be `false` or `null`');
+        }
+        if (prefetchProp !== undefined && !isNavigatingForm) {
+            console.error('Passing `prefetch` to a <Form> whose `action` is a function has no effect.');
+        }
+    }
+    const prefetch = prefetchProp === false || prefetchProp === null ? prefetchProp : null;
+    // Validate `scroll` and `replace`
+    if (process.env.NODE_ENV === 'development') {
+        if (!isNavigatingForm && (replace !== undefined || scroll !== undefined)) {
+            console.error('Passing `replace` or `scroll` to a <Form> whose `action` is a function has no effect.\n' + 'See the relevant docs to learn how to control this behavior for navigations triggered from actions:\n' + '  `redirect()`       - https://nextjs.org/docs/app/api-reference/functions/redirect#parameters\n' + '  `router.replace()` - https://nextjs.org/docs/app/api-reference/functions/use-router#userouter\n');
+        }
+    }
+    // Clean up any unsupported form props (and warn if present)
+    for (const key of DISALLOWED_FORM_PROPS){
+        if (key in props) {
+            if (process.env.NODE_ENV === 'development') {
+                console.error("<Form> does not support changing `" + key + "`. " + (isNavigatingForm ? "If you'd like to use it to perform a mutation, consider making `action` a function instead.\n" + "Learn more: https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations" : ''));
+            }
+            delete props[key];
+        }
+    }
+    const isPrefetchEnabled = // if we don't have an action path, we can't prefetch anything.
+    !!router && isNavigatingForm && prefetch === null;
+    const observeFormVisibilityOnMount = useCallback((element)=>{
+        if (isPrefetchEnabled && router !== null) {
+            mountLinkInstance(element, actionProp, router, PrefetchKind.AUTO);
+        }
+        return ()=>{
+            unmountLinkInstance(element);
+        };
+    }, [
+        isPrefetchEnabled,
+        actionProp,
+        router
+    ]);
+    const mergedRef = useMergedRef(observeFormVisibilityOnMount, externalRef != null ? externalRef : null);
+    if (!isNavigatingForm) {
+        return /*#__PURE__*/ _jsx("form", {
+            ...props,
+            ref: mergedRef
+        });
+    }
+    const actionHref = addBasePath(actionProp);
+    return /*#__PURE__*/ _jsx("form", {
+        ...props,
+        ref: mergedRef,
+        action: actionHref,
+        onSubmit: (event)=>onFormSubmit(event, {
+                router,
+                actionHref,
+                replace,
+                scroll,
+                onSubmit: props.onSubmit
+            })
+    });
+}
+function onFormSubmit(event, param) {
+    let { actionHref, onSubmit, replace, scroll, router } = param;
+    if (typeof onSubmit === 'function') {
+        onSubmit(event);
+        // if the user called event.preventDefault(), do nothing.
+        // (this matches what Link does for `onClick`)
+        if (event.defaultPrevented) {
+            return;
+        }
+    }
+    if (!router) {
+        // Form was somehow used outside of the router (but not in pages, the implementation is forked!).
+        // We can't perform a soft navigation, so let the native submit handling do its thing.
+        return;
+    }
+    const formElement = event.currentTarget;
+    const submitter = event.nativeEvent.submitter;
+    let action = actionHref;
+    if (submitter) {
+        if (process.env.NODE_ENV === 'development') {
+            // the way server actions are encoded (e.g. `formMethod="post")
+            // causes some unnecessary dev-mode warnings from `hasUnsupportedSubmitterAttributes`.
+            // we'd bail out anyway, but we just do it silently.
+            if (hasReactServerActionAttributes(submitter)) {
+                return;
+            }
+        }
+        if (hasUnsupportedSubmitterAttributes(submitter)) {
+            return;
+        }
+        // client actions have `formAction="javascript:..."`. We obviously can't prefetch/navigate to that.
+        if (hasReactClientActionAttributes(submitter)) {
+            return;
+        }
+        // If the submitter specified an alternate formAction,
+        // use that URL instead -- this is what a native form would do.
+        // NOTE: `submitter.formAction` is unreliable, because it will give us `location.href` if it *wasn't* set
+        // NOTE: this should not have `basePath` added, because we can't add it before hydration
+        const submitterFormAction = submitter.getAttribute('formAction');
+        if (submitterFormAction !== null) {
+            if (process.env.NODE_ENV === 'development') {
+                checkFormActionUrl(submitterFormAction, 'formAction');
+            }
+            action = submitterFormAction;
+        }
+    }
+    const targetUrl = createFormSubmitDestinationUrl(action, formElement);
+    // Finally, no more reasons for bailing out.
+    event.preventDefault();
+    const method = replace ? 'replace' : 'push';
+    const targetHref = targetUrl.href;
+    router[method](targetHref, {
+        scroll
+    });
+}
+function hasReactServerActionAttributes(submitter) {
+    // https://github.com/facebook/react/blob/942eb80381b96f8410eab1bef1c539bed1ab0eb1/packages/react-client/src/ReactFlightReplyClient.js#L931-L934
+    const name = submitter.getAttribute('name');
+    return name && (name.startsWith('$ACTION_ID_') || name.startsWith('$ACTION_REF_'));
+}
+
+//# sourceMappingURL=form.js.map

node_modules/next/dist/esm/client/app-dir/link.js

@@ -0,0 +1,315 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { formatUrl } from '../../shared/lib/router/utils/format-url';
+import { AppRouterContext } from '../../shared/lib/app-router-context.shared-runtime';
+import { PrefetchKind } from '../components/router-reducer/router-reducer-types';
+import { useMergedRef } from '../use-merged-ref';
+import { isAbsoluteUrl } from '../../shared/lib/utils';
+import { addBasePath } from '../add-base-path';
+import { warnOnce } from '../../shared/lib/utils/warn-once';
+import { mountLinkInstance, onNavigationIntent, unmountLinkInstance } from '../components/links';
+function isModifiedEvent(event) {
+    const eventTarget = event.currentTarget;
+    const target = eventTarget.getAttribute('target');
+    return target && target !== '_self' || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || // triggers resource download
+    event.nativeEvent && event.nativeEvent.which === 2;
+}
+function linkClicked(e, router, href, as, replace, shallow, scroll) {
+    const { nodeName } = e.currentTarget;
+    // anchors inside an svg have a lowercase nodeName
+    const isAnchorNodeName = nodeName.toUpperCase() === 'A';
+    if (isAnchorNodeName && isModifiedEvent(e)) {
+        // ignore click for browser’s default behavior
+        return;
+    }
+    e.preventDefault();
+    const navigate = ()=>{
+        // If the router is an NextRouter instance it will have `beforePopState`
+        const routerScroll = scroll != null ? scroll : true;
+        if ('beforePopState' in router) {
+            router[replace ? 'replace' : 'push'](href, as, {
+                shallow,
+                scroll: routerScroll
+            });
+        } else {
+            router[replace ? 'replace' : 'push'](as || href, {
+                scroll: routerScroll
+            });
+        }
+    };
+    React.startTransition(navigate);
+}
+function formatStringOrUrl(urlObjOrString) {
+    if (typeof urlObjOrString === 'string') {
+        return urlObjOrString;
+    }
+    return formatUrl(urlObjOrString);
+}
+/**
+ * A React component that extends the HTML `<a>` element to provide
+ * [prefetching](https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating#2-prefetching)
+ * and client-side navigation. This is the primary way to navigate between routes in Next.js.
+ *
+ * @remarks
+ * - Prefetching is only enabled in production.
+ *
+ * @see https://nextjs.org/docs/app/api-reference/components/link
+ */ const Link = /*#__PURE__*/ React.forwardRef(function LinkComponent(props, forwardedRef) {
+    let children;
+    const { href: hrefProp, as: asProp, children: childrenProp, prefetch: prefetchProp = null, passHref, replace, shallow, scroll, onClick, onMouseEnter: onMouseEnterProp, onTouchStart: onTouchStartProp, legacyBehavior = false, ...restProps } = props;
+    children = childrenProp;
+    if (legacyBehavior && (typeof children === 'string' || typeof children === 'number')) {
+        children = /*#__PURE__*/ _jsx("a", {
+            children: children
+        });
+    }
+    const router = React.useContext(AppRouterContext);
+    const prefetchEnabled = prefetchProp !== false;
+    /**
+     * The possible states for prefetch are:
+     * - null: this is the default "auto" mode, where we will prefetch partially if the link is in the viewport
+     * - true: we will prefetch if the link is visible and prefetch the full page, not just partially
+     * - false: we will not prefetch if in the viewport at all
+     */ const appPrefetchKind = prefetchProp === null ? PrefetchKind.AUTO : PrefetchKind.FULL;
+    if (process.env.NODE_ENV !== 'production') {
+        function createPropError(args) {
+            return Object.defineProperty(new Error("Failed prop type: The prop `" + args.key + "` expects a " + args.expected + " in `<Link>`, but got `" + args.actual + "` instead." + (typeof window !== 'undefined' ? "\nOpen your browser's console to view the Component stack trace." : '')), "__NEXT_ERROR_CODE", {
+                value: "E319",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        // TypeScript trick for type-guarding:
+        const requiredPropsGuard = {
+            href: true
+        };
+        const requiredProps = Object.keys(requiredPropsGuard);
+        requiredProps.forEach((key)=>{
+            if (key === 'href') {
+                if (props[key] == null || typeof props[key] !== 'string' && typeof props[key] !== 'object') {
+                    throw createPropError({
+                        key,
+                        expected: '`string` or `object`',
+                        actual: props[key] === null ? 'null' : typeof props[key]
+                    });
+                }
+            } else {
+                // TypeScript trick for type-guarding:
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const _ = key;
+            }
+        });
+        // TypeScript trick for type-guarding:
+        const optionalPropsGuard = {
+            as: true,
+            replace: true,
+            scroll: true,
+            shallow: true,
+            passHref: true,
+            prefetch: true,
+            onClick: true,
+            onMouseEnter: true,
+            onTouchStart: true,
+            legacyBehavior: true
+        };
+        const optionalProps = Object.keys(optionalPropsGuard);
+        optionalProps.forEach((key)=>{
+            const valType = typeof props[key];
+            if (key === 'as') {
+                if (props[key] && valType !== 'string' && valType !== 'object') {
+                    throw createPropError({
+                        key,
+                        expected: '`string` or `object`',
+                        actual: valType
+                    });
+                }
+            } else if (key === 'onClick' || key === 'onMouseEnter' || key === 'onTouchStart') {
+                if (props[key] && valType !== 'function') {
+                    throw createPropError({
+                        key,
+                        expected: '`function`',
+                        actual: valType
+                    });
+                }
+            } else if (key === 'replace' || key === 'scroll' || key === 'shallow' || key === 'passHref' || key === 'prefetch' || key === 'legacyBehavior') {
+                if (props[key] != null && valType !== 'boolean') {
+                    throw createPropError({
+                        key,
+                        expected: '`boolean`',
+                        actual: valType
+                    });
+                }
+            } else {
+                // TypeScript trick for type-guarding:
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const _ = key;
+            }
+        });
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        if (props.locale) {
+            warnOnce('The `locale` prop is not supported in `next/link` while using the `app` router. Read more about app router internalization: https://nextjs.org/docs/app/building-your-application/routing/internationalization');
+        }
+        if (!asProp) {
+            let href;
+            if (typeof hrefProp === 'string') {
+                href = hrefProp;
+            } else if (typeof hrefProp === 'object' && typeof hrefProp.pathname === 'string') {
+                href = hrefProp.pathname;
+            }
+            if (href) {
+                const hasDynamicSegment = href.split('/').some((segment)=>segment.startsWith('[') && segment.endsWith(']'));
+                if (hasDynamicSegment) {
+                    throw Object.defineProperty(new Error("Dynamic href `" + href + "` found in <Link> while using the `/app` router, this is not supported. Read more: https://nextjs.org/docs/messages/app-dir-dynamic-href"), "__NEXT_ERROR_CODE", {
+                        value: "E267",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+            }
+        }
+    }
+    const { href, as } = React.useMemo(()=>{
+        const resolvedHref = formatStringOrUrl(hrefProp);
+        return {
+            href: resolvedHref,
+            as: asProp ? formatStringOrUrl(asProp) : resolvedHref
+        };
+    }, [
+        hrefProp,
+        asProp
+    ]);
+    // This will return the first child, if multiple are provided it will throw an error
+    let child;
+    if (legacyBehavior) {
+        if (process.env.NODE_ENV === 'development') {
+            if (onClick) {
+                console.warn('"onClick" was passed to <Link> with `href` of `' + hrefProp + '` but "legacyBehavior" was set. The legacy behavior requires onClick be set on the child of next/link');
+            }
+            if (onMouseEnterProp) {
+                console.warn('"onMouseEnter" was passed to <Link> with `href` of `' + hrefProp + '` but "legacyBehavior" was set. The legacy behavior requires onMouseEnter be set on the child of next/link');
+            }
+            try {
+                child = React.Children.only(children);
+            } catch (err) {
+                if (!children) {
+                    throw Object.defineProperty(new Error("No children were passed to <Link> with `href` of `" + hrefProp + "` but one child is required https://nextjs.org/docs/messages/link-no-children"), "__NEXT_ERROR_CODE", {
+                        value: "E320",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+                throw Object.defineProperty(new Error("Multiple children were passed to <Link> with `href` of `" + hrefProp + "` but only one child is supported https://nextjs.org/docs/messages/link-multiple-children" + (typeof window !== 'undefined' ? " \nOpen your browser's console to view the Component stack trace." : '')), "__NEXT_ERROR_CODE", {
+                    value: "E266",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        } else {
+            child = React.Children.only(children);
+        }
+    } else {
+        if (process.env.NODE_ENV === 'development') {
+            if ((children == null ? void 0 : children.type) === 'a') {
+                throw Object.defineProperty(new Error('Invalid <Link> with <a> child. Please remove <a> or use <Link legacyBehavior>.\nLearn more: https://nextjs.org/docs/messages/invalid-new-link-with-extra-anchor'), "__NEXT_ERROR_CODE", {
+                    value: "E209",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        }
+    }
+    const childRef = legacyBehavior ? child && typeof child === 'object' && child.ref : forwardedRef;
+    // Use a callback ref to attach an IntersectionObserver to the anchor tag on
+    // mount. In the future we will also use this to keep track of all the
+    // currently mounted <Link> instances, e.g. so we can re-prefetch them after
+    // a revalidation or refresh.
+    const observeLinkVisibilityOnMount = React.useCallback((element)=>{
+        if (prefetchEnabled && router !== null) {
+            mountLinkInstance(element, href, router, appPrefetchKind);
+        }
+        return ()=>{
+            unmountLinkInstance(element);
+        };
+    }, [
+        prefetchEnabled,
+        href,
+        router,
+        appPrefetchKind
+    ]);
+    const mergedRef = useMergedRef(observeLinkVisibilityOnMount, childRef);
+    const childProps = {
+        ref: mergedRef,
+        onClick (e) {
+            if (process.env.NODE_ENV !== 'production') {
+                if (!e) {
+                    throw Object.defineProperty(new Error('Component rendered inside next/link has to pass click event to "onClick" prop.'), "__NEXT_ERROR_CODE", {
+                        value: "E312",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+            }
+            if (!legacyBehavior && typeof onClick === 'function') {
+                onClick(e);
+            }
+            if (legacyBehavior && child.props && typeof child.props.onClick === 'function') {
+                child.props.onClick(e);
+            }
+            if (!router) {
+                return;
+            }
+            if (e.defaultPrevented) {
+                return;
+            }
+            linkClicked(e, router, href, as, replace, shallow, scroll);
+        },
+        onMouseEnter (e) {
+            if (!legacyBehavior && typeof onMouseEnterProp === 'function') {
+                onMouseEnterProp(e);
+            }
+            if (legacyBehavior && child.props && typeof child.props.onMouseEnter === 'function') {
+                child.props.onMouseEnter(e);
+            }
+            if (!router) {
+                return;
+            }
+            if (!prefetchEnabled || process.env.NODE_ENV === 'development') {
+                return;
+            }
+            onNavigationIntent(e.currentTarget);
+        },
+        onTouchStart: process.env.__NEXT_LINK_NO_TOUCH_START ? undefined : function onTouchStart(e) {
+            if (!legacyBehavior && typeof onTouchStartProp === 'function') {
+                onTouchStartProp(e);
+            }
+            if (legacyBehavior && child.props && typeof child.props.onTouchStart === 'function') {
+                child.props.onTouchStart(e);
+            }
+            if (!router) {
+                return;
+            }
+            if (!prefetchEnabled) {
+                return;
+            }
+            onNavigationIntent(e.currentTarget);
+        }
+    };
+    // If child is an <a> tag and doesn't have a href attribute, or if the 'passHref' property is
+    // defined, we specify the current 'href', so that repetition is not needed by the user.
+    // If the url is absolute, we can bypass the logic to prepend the basePath.
+    if (isAbsoluteUrl(as)) {
+        childProps.href = as;
+    } else if (!legacyBehavior || passHref || child.type === 'a' && !('href' in child.props)) {
+        childProps.href = addBasePath(as);
+    }
+    return legacyBehavior ? /*#__PURE__*/ React.cloneElement(child, childProps) : /*#__PURE__*/ _jsx("a", {
+        ...restProps,
+        ...childProps,
+        children: children
+    });
+});
+export default Link;
+
+//# sourceMappingURL=link.js.map