@shuvi/platform-web 0.0.1-rc.34 → 1.0.0-rc.2

package/esm/shuvi-app/react/ErrorBoundary.jsx

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import { SHUVI_ERROR } from '@shuvi/shared/lib/constants';
+import ErrorPage from './ErrorPage';
+class ErrorBoundary extends React.PureComponent {
+    constructor() {
+        super(...arguments);
+        this.state = { error: null };
+    }
+    componentDidCatch(error, 
+    // Loosely typed because it depends on the React version and was
+    // accidentally excluded in some versions.
+    errorInfo) {
+        this.setState({ error });
+        console.error('the error is below: \n', error);
+        if (errorInfo && errorInfo.componentStack) {
+            console.error('the componentStack is below: \n', errorInfo.componentStack);
+        }
+    }
+    render() {
+        return this.state.error ? (
+        // The component has to be unmounted or else it would continue to error
+        <ErrorPage code={SHUVI_ERROR.APP_ERROR.code} message={SHUVI_ERROR.APP_ERROR.message}/>) : this.props.children;
+    }
+}
+export { ErrorBoundary };

package/esm/shuvi-app/react/ErrorPage.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export default function ErrorPage({ code, message }: {
+    code?: number;
+    message?: string;
+}): JSX.Element;

package/esm/shuvi-app/react/ErrorPage.jsx

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import error from './Error';
+import userError from '@shuvi/app/core/error';
+const Error = userError || error;
+export default function ErrorPage({ code, message }) {
+    return <Error errorCode={code} errorDesc={message}/>;
+}

package/esm/shuvi-app/react/Link.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { LinkProps } from '@shuvi/router-react';
+export declare const Link: ({ prefetch, onMouseEnter, to, ref, ...rest }: LinkWrapperProps) => JSX.Element;
+interface LinkWrapperProps extends LinkProps {
+    ref?: any;
+}
+export {};

package/esm/shuvi-app/react/Link.jsx

@@ -0,0 +1,115 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import * as React from 'react';
+import { Link as LinkFromRouterReact, RouterContext } from '@shuvi/router-react';
+import { getFilesOfRoute } from '@shuvi/platform-shared/shared';
+import useIntersection from './utils/useIntersection';
+const ABSOLUTE_URL_REGEX = /^[a-zA-Z][a-zA-Z\d+\-.]*?:/;
+const prefetched = {};
+function hasSupportPrefetch() {
+    try {
+        const link = document.createElement('link');
+        return link.relList.supports('prefetch');
+    }
+    catch (e) {
+        return false;
+    }
+}
+function prefetchViaDom(href, id, as) {
+    return new Promise((res, rej) => {
+        const selector = `
+        link[rel="prefetch"][href^="${href}"],
+        script[src^="${href}"]`;
+        if (document.querySelector(selector)) {
+            return res();
+        }
+        const link = document.createElement('link');
+        // The order of property assignment here is intentional:
+        if (as)
+            link.as = as;
+        link.rel = `prefetch`;
+        link.onload = res;
+        link.onerror = rej;
+        link.dataset.id = id;
+        // `href` should always be last:
+        link.href = href;
+        document.head.appendChild(link);
+    });
+}
+function prefetchFn(router, to) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const files = getFilesOfRoute(router, to);
+        if (process.env.NODE_ENV !== 'production')
+            return;
+        if (typeof window === 'undefined')
+            return;
+        const canPrefetch = hasSupportPrefetch();
+        yield Promise.all(canPrefetch
+            ? files.js.map(({ url, id }) => prefetchViaDom(url, id, 'script'))
+            : []);
+    });
+}
+const isAbsoluteUrl = (url) => {
+    return ABSOLUTE_URL_REGEX.test(url);
+};
+export const Link = function LinkWithPrefetch(_a) {
+    var { prefetch, onMouseEnter, to, ref } = _a, rest = __rest(_a, ["prefetch", "onMouseEnter", "to", "ref"]);
+    const isHrefValid = typeof to === 'string' && !isAbsoluteUrl(to);
+    const previousHref = React.useRef(to);
+    const [setIntersectionRef, isVisible, resetVisible] = useIntersection({});
+    const { router } = React.useContext(RouterContext);
+    const setRef = React.useCallback((el) => {
+        // Before the link getting observed, check if visible state need to be reset
+        if (isHrefValid && previousHref.current !== to) {
+            resetVisible();
+            previousHref.current = to;
+        }
+        if (isHrefValid && prefetch !== false)
+            setIntersectionRef(el);
+        if (ref) {
+            if (typeof ref === 'function')
+                ref(el);
+            else if (typeof ref === 'object') {
+                ref.current = el;
+            }
+        }
+    }, [to, isHrefValid, prefetch, resetVisible, setIntersectionRef, ref]);
+    React.useEffect(() => {
+        const shouldPrefetch = isHrefValid && prefetch !== false && isVisible;
+        if (shouldPrefetch && !prefetched[to]) {
+            prefetchFn(router, to);
+            prefetched[to] = true;
+        }
+    }, [to, prefetch, isVisible]);
+    const childProps = {
+        ref: setRef,
+        onMouseEnter: (e) => {
+            if (typeof onMouseEnter === 'function') {
+                onMouseEnter(e);
+            }
+            if (isHrefValid && !prefetched[to]) {
+                prefetchFn(router, to);
+                prefetched[to] = true;
+            }
+        }
+    };
+    return <LinkFromRouterReact to={to} {...rest} {...childProps}/>;
+};

package/esm/shuvi-app/react/applicationContext.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { IApplication } from '@shuvi/platform-shared/shared';
+export declare const ApplicationContext: React.Context<IApplication>;
+export declare function AppProvider({ app, children }: React.PropsWithChildren<{
+    app: IApplication;
+}>): JSX.Element;
+export declare function useApp(): IApplication;

package/esm/shuvi-app/react/applicationContext.jsx

@@ -0,0 +1,10 @@
+import * as React from 'react';
+export const ApplicationContext = React.createContext(null);
+export function AppProvider({ app, children }) {
+    return (<ApplicationContext.Provider value={app}>
+      {children}
+    </ApplicationContext.Provider>);
+}
+export function useApp() {
+    return React.useContext(ApplicationContext);
+}

package/esm/shuvi-app/react/dynamic.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+export declare type LoaderComponent<P = {}> = Promise<React.ComponentType<P> | {
+    default: React.ComponentType<P>;
+}>;
+export declare type Loader<P = {}> = () => LoaderComponent<P>;
+export declare type LoadableGeneratedOptions = {
+    webpack?(): string[];
+    modules?: string[];
+};
+export declare type LoadableBaseOptions<P = {}> = LoadableGeneratedOptions & {
+    loading?: ({ error, isLoading, pastDelay }: {
+        error?: Error | null;
+        isLoading?: boolean;
+        pastDelay?: boolean;
+        timedOut?: boolean;
+    }) => JSX.Element | null;
+    loader?: Loader<P>;
+    ssr?: boolean;
+};
+export declare type DynamicOptions<P = {}> = LoadableBaseOptions<P>;
+export declare type LoaderFn<P = {}> = (opts: DynamicOptions<P>) => React.ComponentType<P>;
+export declare type LoadableComponent<P = {}> = React.ComponentType<P>;
+export declare function noSSR<P = {}>(LoadableInitializer: LoaderFn<P>, dynamicOptions: DynamicOptions<P>): React.ComponentType<P> | (() => JSX.Element);
+/**
+ *  ES2020 [dynamic import()](https://github.com/tc39/proposal-dynamic-import) for JavaScript
+ *
+ * @param dynamicOptions {@link DynamicOptions} | {@link Loader}
+ * @param options {@link DynamicOptions}
+ * @returns React.ComponentType
+ */
+export default function dynamic<P = {}>(dynamicOptions: DynamicOptions<P> | Loader<P>, options?: DynamicOptions<P>): React.ComponentType<P>;

package/esm/shuvi-app/react/dynamic.jsx

@@ -0,0 +1,62 @@
+import * as React from 'react';
+import Loadable from './loadable';
+const isServerSide = typeof window === 'undefined';
+export function noSSR(LoadableInitializer, dynamicOptions) {
+    // Removing webpack and modules means react-loadable won't try preloading
+    delete dynamicOptions.webpack;
+    delete dynamicOptions.modules;
+    // This check is neccesary to prevent react-loadable from initializing on the server
+    if (!isServerSide) {
+        return LoadableInitializer(dynamicOptions);
+    }
+    const Loading = dynamicOptions.loading;
+    // This will only be rendered on the server side
+    return () => (<Loading error={null} isLoading pastDelay={false} timedOut={false}/>);
+}
+/**
+ *  ES2020 [dynamic import()](https://github.com/tc39/proposal-dynamic-import) for JavaScript
+ *
+ * @param dynamicOptions {@link DynamicOptions} | {@link Loader}
+ * @param options {@link DynamicOptions}
+ * @returns React.ComponentType
+ */
+export default function dynamic(dynamicOptions, options) {
+    let loadableFn = Loadable;
+    let loadableOptions = {
+        // A loading component is not required, so we default it
+        loading: ({ error, isLoading, pastDelay }) => {
+            if (!pastDelay)
+                return null;
+            if (process.env.NODE_ENV === 'development') {
+                if (isLoading) {
+                    return null;
+                }
+                if (error) {
+                    return (<p>
+              {error.message}
+              <br />
+              {error.stack}
+            </p>);
+                }
+            }
+            return null;
+        }
+    };
+    if (typeof dynamicOptions === 'function') {
+        loadableOptions.loader = dynamicOptions;
+        // Support for having first argument being options, eg: dynamic({loader: import('../hello-world')})
+    }
+    else if (typeof dynamicOptions === 'object') {
+        loadableOptions = Object.assign(Object.assign({}, loadableOptions), dynamicOptions);
+    }
+    // Support for passing options, eg: dynamic(import('../hello-world'), {loading: () => <p>Loading something</p>})
+    loadableOptions = Object.assign(Object.assign({}, loadableOptions), options);
+    if (typeof loadableOptions.ssr === 'boolean') {
+        if (!loadableOptions.ssr) {
+            delete loadableOptions.ssr;
+            return noSSR(loadableFn, loadableOptions);
+        }
+        delete loadableOptions.ssr;
+    }
+    return loadableFn(loadableOptions);
+}

package/esm/shuvi-app/react/getRoutes.d.ts

@@ -0,0 +1,2 @@
+import { IPageRouteRecord, IRawPageRouteRecord } from '@shuvi/platform-shared/shared';
+export default function getRoutes(routes: IRawPageRouteRecord[]): IPageRouteRecord[];

package/esm/shuvi-app/react/getRoutes.js

@@ -0,0 +1,31 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { loadRouteComponent } from './loadRouteComponent';
+export default function getRoutes(routes) {
+    const getRoutesWithRequire = (routes) => routes.map(x => {
+        const originalRoute = Object.assign({}, x);
+        const { __componentSource__, __componentSourceWithAffix__, __import__, __resolveWeak__, children } = originalRoute, rest = __rest(originalRoute, ["__componentSource__", "__componentSourceWithAffix__", "__import__", "__resolveWeak__", "children"]);
+        const route = Object.assign({}, rest);
+        if (children) {
+            route.children = getRoutesWithRequire(children);
+        }
+        if (__componentSourceWithAffix__ && __import__) {
+            route.component = loadRouteComponent(__import__, {
+                webpack: __resolveWeak__,
+                modules: [__componentSourceWithAffix__]
+            });
+        }
+        return Object.assign({ __componentSourceWithAffix__, __resolveWeak__ }, route);
+    });
+    const routesWithRequire = getRoutesWithRequire(routes || []);
+    return routesWithRequire;
+}

package/esm/shuvi-app/react/head/head-manager-context.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare const HeadManagerContext: React.Context<any>;

package/esm/shuvi-app/react/head/head-manager-context.js

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export const HeadManagerContext = React.createContext(null);

package/esm/shuvi-app/react/head/head-manager.d.ts

@@ -0,0 +1,10 @@
+import { HeadState } from './types';
+export default class HeadManager {
+    private _pedningPromise;
+    private _head;
+    constructor();
+    updateHead(head: HeadState): void;
+    private _doUpdateHead;
+    private _updateTitle;
+    private _updateElements;
+}

package/esm/shuvi-app/react/head/head-manager.js

@@ -0,0 +1,93 @@
+// Based on https://github.com/zeit/next.js
+// License: https://github.com/zeit/next.js/blob/977bf8d9ebd2845241b8689317f36e4e487f39d0/license.md
+import { SHUVI_HEAD_ATTRIBUTE } from './head';
+export default class HeadManager {
+    constructor() {
+        this._pedningPromise = null;
+        this.updateHead = this.updateHead.bind(this);
+    }
+    updateHead(head) {
+        this._head = head;
+        if (this._pedningPromise) {
+            return;
+        }
+        this._pedningPromise = Promise.resolve().then(() => {
+            this._pedningPromise = null;
+            this._doUpdateHead();
+        });
+    }
+    _doUpdateHead() {
+        const tags = {};
+        this._head.forEach(h => {
+            (tags[h.tagName] || (tags[h.tagName] = [])).push(h);
+        });
+        if (tags.title) {
+            this._updateTitle(tags.title[0]);
+        }
+        const types = ['meta', 'base', 'link', 'style', 'script'];
+        types.forEach(type => {
+            this._updateElements(type, tags[type] || []);
+        });
+    }
+    _updateTitle({ attrs }) {
+        const title = attrs.textContent || '';
+        if (title !== document.title)
+            document.title = title;
+        const titleEle = document.getElementsByTagName('title')[0];
+        if (titleEle) {
+            assignAttributes(titleEle, attrs);
+        }
+    }
+    _updateElements(type, tags) {
+        const headEl = document.getElementsByTagName('head')[0];
+        const oldNodes = headEl.querySelectorAll(`${type}[${SHUVI_HEAD_ATTRIBUTE}='true']`);
+        const oldTags = Array.prototype.slice.call(oldNodes);
+        let divideElement = null;
+        if (oldTags.length) {
+            divideElement = oldTags[oldTags.length - 1].nextElementSibling;
+        }
+        const newTags = tags.map(tagToDOM).filter(newTag => {
+            for (let k = 0, len = oldTags.length; k < len; k++) {
+                const oldTag = oldTags[k];
+                if (oldTag.isEqualNode(newTag)) {
+                    oldTags.splice(k, 1);
+                    return false;
+                }
+            }
+            return true;
+        });
+        oldTags.forEach(t => t.parentNode.removeChild(t));
+        newTags.forEach(t => {
+            if (divideElement) {
+                headEl.insertBefore(t, divideElement);
+            }
+            else {
+                headEl.appendChild(t);
+            }
+        });
+    }
+}
+function assignAttributes(el, attrs) {
+    for (const a in attrs) {
+        if (!Object.prototype.hasOwnProperty.call(attrs, a))
+            continue;
+        if (a === 'textContent')
+            continue;
+        // we don't render undefined props to the DOM
+        if (attrs[a] === undefined)
+            continue;
+        el.setAttribute(a.toLowerCase(), attrs[a]);
+    }
+}
+function tagToDOM({ tagName, attrs, innerHTML }) {
+    const el = document.createElement(tagName);
+    assignAttributes(el, attrs);
+    const { textContent } = attrs;
+    if (innerHTML) {
+        el.innerHTML = innerHTML;
+    }
+    else if (textContent) {
+        el.textContent = textContent;
+    }
+    return el;
+}

package/esm/shuvi-app/react/head/head.d.ts

@@ -0,0 +1,33 @@
+import * as React from 'react';
+import { HeadState } from './types';
+export declare const SHUVI_HEAD_ATTRIBUTE = "data-shuvi-head";
+/**
+ * This component injects elements to `<head>` of your page.
+ * To avoid duplicated `tags` in `<head>` you can use the `key` property, which will make sure every tag is only rendered once.
+ *
+ * ```ts
+ * import { Head } from "@shuvi/runtime";
+ *
+ * function IndexPage() {
+ *   return (
+ *     <div>
+ *       <Head>
+ *         <title>My page title</title>
+ *         <meta name="viewport" content="initial-scale=1.0, width=device-width" />
+ *       </Head>
+ *       <p>Hello world!</p>
+ *    </div>
+ *  );
+ * }
+ *
+ * export default IndexPage;
+ * ```
+ *
+ */
+declare function Head({ children }: {
+    children?: React.ReactNode;
+}): JSX.Element;
+declare namespace Head {
+    var rewind: () => HeadState | undefined;
+}
+export default Head;

package/esm/shuvi-app/react/head/head.jsx

@@ -0,0 +1,178 @@
+// Based on https://github.com/zeit/next.js
+// License: https://github.com/zeit/next.js/blob/977bf8d9ebd2845241b8689317f36e4e487f39d0/license.md
+import * as React from 'react';
+import withSideEffect from './side-effect';
+import { HeadManagerContext } from './head-manager-context';
+export const SHUVI_HEAD_ATTRIBUTE = 'data-shuvi-head';
+const DOMAttributeNames = {
+    acceptCharset: 'accept-charset',
+    className: 'class',
+    htmlFor: 'for',
+    httpEquiv: 'http-equiv'
+};
+function reactElementToTag({ type, props }) {
+    const tag = {
+        tagName: type,
+        attrs: {}
+    };
+    for (const p in props) {
+        if (!props.hasOwnProperty(p))
+            continue;
+        if (p === 'children' || p === 'dangerouslySetInnerHTML')
+            continue;
+        // we don't render undefined props to the DOM
+        if (props[p] === undefined)
+            continue;
+        const attr = DOMAttributeNames[p] || p.toLowerCase();
+        tag.attrs[attr] = props[p];
+    }
+    const { children, dangerouslySetInnerHTML } = props;
+    if (dangerouslySetInnerHTML) {
+        tag.innerHTML = dangerouslySetInnerHTML.__html || '';
+    }
+    else if (children) {
+        tag.attrs.textContent =
+            typeof children === 'string' ? children : children.join('');
+    }
+    return tag;
+}
+function onlyReactElement(list, child) {
+    // React children can be "string" or "number" in this case we ignore them for backwards compat
+    if (typeof child === 'string' || typeof child === 'number') {
+        return list;
+    }
+    // Adds support for React.Fragment
+    if (child.type === React.Fragment) {
+        return list.concat(React.Children.toArray(child.props.children).reduce((fragmentList, fragmentChild) => {
+            if (typeof fragmentChild === 'string' ||
+                typeof fragmentChild === 'number') {
+                return fragmentList;
+            }
+            return fragmentList.concat(fragmentChild);
+        }, []));
+    }
+    return list.concat(child);
+}
+const METATYPES = ['name', 'httpEquiv', 'charSet', 'itemProp'];
+/*
+ returns a function for filtering head child elements
+ which shouldn't be duplicated, like <title/>
+ Also adds support for deduplicated `key` properties
+*/
+function unique() {
+    const keys = new Set();
+    const tags = new Set();
+    const metaTypes = new Set();
+    const metaCategories = {};
+    return (h) => {
+        let unique = true;
+        if (h.key && typeof h.key !== 'number' && h.key.indexOf('$') > 0) {
+            const key = h.key.slice(h.key.indexOf('$') + 1);
+            if (keys.has(key)) {
+                unique = false;
+            }
+            else {
+                keys.add(key);
+            }
+        }
+        // eslint-disable-next-line default-case
+        switch (h.type) {
+            case 'title':
+            case 'base':
+                if (tags.has(h.type)) {
+                    unique = false;
+                }
+                else {
+                    tags.add(h.type);
+                }
+                break;
+            case 'meta':
+                for (let i = 0, len = METATYPES.length; i < len; i++) {
+                    const metatype = METATYPES[i];
+                    if (!h.props.hasOwnProperty(metatype))
+                        continue;
+                    if (metatype === 'charSet') {
+                        if (metaTypes.has(metatype)) {
+                            unique = false;
+                        }
+                        else {
+                            metaTypes.add(metatype);
+                        }
+                    }
+                    else {
+                        const category = h.props[metatype];
+                        const categories = metaCategories[metatype] || new Set();
+                        if (categories.has(category)) {
+                            unique = false;
+                        }
+                        else {
+                            categories.add(category);
+                            metaCategories[metatype] = categories;
+                        }
+                    }
+                }
+                break;
+        }
+        return unique;
+    };
+}
+function onlyHeadElement(element) {
+    return typeof element.type === 'string';
+}
+/**
+ *
+ * @param headElement List of multiple <Head> instances
+ */
+function reduceComponents(headElements) {
+    return headElements
+        .reduce((list, headElement) => {
+        const headElementChildren = React.Children.toArray(headElement.props.children);
+        return list.concat(headElementChildren);
+    }, [])
+        .reduce(onlyReactElement, [])
+        .filter(onlyHeadElement)
+        .reverse()
+        .filter(unique())
+        .reverse()
+        .map(e => {
+        const { type, props } = e;
+        const headElement = {
+            type,
+            props: Object.assign(Object.assign({}, props), { [SHUVI_HEAD_ATTRIBUTE]: 'true' })
+        };
+        return reactElementToTag(headElement);
+    });
+}
+const Effect = withSideEffect();
+/**
+ * This component injects elements to `<head>` of your page.
+ * To avoid duplicated `tags` in `<head>` you can use the `key` property, which will make sure every tag is only rendered once.
+ *
+ * ```ts
+ * import { Head } from "@shuvi/runtime";
+ *
+ * function IndexPage() {
+ *   return (
+ *     <div>
+ *       <Head>
+ *         <title>My page title</title>
+ *         <meta name="viewport" content="initial-scale=1.0, width=device-width" />
+ *       </Head>
+ *       <p>Hello world!</p>
+ *    </div>
+ *  );
+ * }
+ *
+ * export default IndexPage;
+ * ```
+ *
+ */
+function Head({ children }) {
+    return (<HeadManagerContext.Consumer>
+      {updateHead => (<Effect reduceComponentsToState={reduceComponents} handleStateChange={updateHead}>
+          {children}
+        </Effect>)}
+    </HeadManagerContext.Consumer>);
+}
+Head.rewind = Effect.rewind;
+export default Head;

package/esm/shuvi-app/react/head/index.d.ts

@@ -0,0 +1,4 @@
+import Head from './head';
+import HeadManager from './head-manager';
+export { HeadManagerContext } from './head-manager-context';
+export { Head, HeadManager };

package/esm/shuvi-app/react/head/index.js

@@ -0,0 +1,4 @@
+import Head from './head';
+import HeadManager from './head-manager';
+export { HeadManagerContext } from './head-manager-context';
+export { Head, HeadManager };