@nascentdigital/funnel-editor 4.4.18

package/dist/core/repository/SiteRepository.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SiteRepository = void 0;
+// class
+class SiteRepository {
+    constructor(editorApi) {
+        this.editorApi = editorApi;
+    }
+}
+exports.SiteRepository = SiteRepository;

package/dist/core/repository/TagSerializer.d.ts

@@ -0,0 +1,8 @@
+import { Schema } from '@nascentdigital/funnel-core';
+export declare namespace TagSerializer {
+    type DeserializeTagsArgs = {
+        groups: ReadonlyArray<Schema.TagGroup>;
+        tagsData: Schema.TagGroup.Data;
+    };
+    function deserializeTags({ groups, tagsData }: DeserializeTagsArgs): Schema.Tag[];
+}

package/dist/core/repository/TagSerializer.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagSerializer = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// namespace
+var TagSerializer;
+(function (TagSerializer) {
+    function deserializeTags({ groups, tagsData }) {
+        return tagsData
+            // convert tags
+            .map(tagData => {
+            // parse data into components (or skip)
+            const components = funnel_core_1.Schema.Tag.Data.parse(tagData);
+            if (!components) {
+                return undefined;
+            }
+            // find group (or skip)
+            const { tagGroupId, tagId } = components;
+            const group = groups.find(group => group.id === tagGroupId);
+            return group === null || group === void 0 ? void 0 : group.get(tagId);
+        })
+            // filter out bad tags
+            .filter(funnel_core_1.Value.isDefined);
+    }
+    TagSerializer.deserializeTags = deserializeTags;
+})(TagSerializer || (exports.TagSerializer = TagSerializer = {}));

package/dist/core/repository/index.d.ts

@@ -0,0 +1,9 @@
+export * from './CollectionRepository';
+export * from './CollectionSerializer';
+export * from './CollectionTarget';
+export * from './FieldSerializer';
+export * from './PageRepository';
+export * from './PageSerializer';
+export * from './PageTarget';
+export * from './SiteRepository';
+export * from './TagSerializer';

package/dist/core/repository/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./CollectionRepository"), exports);
+__exportStar(require("./CollectionSerializer"), exports);
+__exportStar(require("./CollectionTarget"), exports);
+__exportStar(require("./FieldSerializer"), exports);
+__exportStar(require("./PageRepository"), exports);
+__exportStar(require("./PageSerializer"), exports);
+__exportStar(require("./PageTarget"), exports);
+__exportStar(require("./SiteRepository"), exports);
+__exportStar(require("./TagSerializer"), exports);

package/dist/core/routing/index.d.ts

@@ -0,0 +1 @@
+export * from './useEditorRouter';

package/dist/core/routing/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./useEditorRouter"), exports);

package/dist/core/routing/useEditorRouter.d.ts

@@ -0,0 +1,105 @@
+import { Language, RegionsConfig, Schema } from '@nascentdigital/funnel-core';
+import { NextRouter } from 'next/router';
+import { Authenticator } from '../auth';
+export declare function useEditorRouter(): EditorRouter;
+export declare class EditorRouter {
+    private readonly _nextRouter;
+    private readonly _authenticator;
+    readonly regions: string[];
+    readonly includesRegions: boolean;
+    private _cachedRoute?;
+    constructor(_nextRouter: NextRouter, _authenticator: Authenticator);
+    get ready(): boolean;
+    get region(): RegionsConfig.RegionConfig.WithId | undefined;
+    get route(): EditorRouter.Route | undefined;
+    reload(): void;
+    navigateToLogin(options?: EditorRouter.NavigateOptions): Promise<void>;
+    navigateToLoginReset(options?: EditorRouter.NavigateOptions): Promise<void>;
+    navigateToDashboard(options?: EditorRouter.NavigateOptions): Promise<void>;
+    navigateToTemplates(target: Omit<EditorRouter.Route.Templates, 'target'>, options?: EditorRouter.NavigateOptions): Promise<void>;
+    navigateToPages(target: Omit<EditorRouter.Route.Pages, 'target'>, options?: EditorRouter.NavigateOptions): Promise<void>;
+    navigateToPage(target: Omit<EditorRouter.Route.Page, 'target'>, options?: EditorRouter.NavigateOptions): Promise<void>;
+    navigateToCollections(options?: EditorRouter.NavigateOptions): Promise<void>;
+    navigateToCollectionItems(target: Omit<EditorRouter.Route.CollectionItems, 'target'>, options?: EditorRouter.NavigateOptions): Promise<void>;
+    navigateToCollection(target: Omit<EditorRouter.Route.Collection, 'target'>, options?: EditorRouter.NavigateOptions): Promise<void>;
+    navigateToChangeSets(options?: EditorRouter.NavigateOptions): Promise<void>;
+    navigateToChangeSet(changeSetId: Schema.ChangeSet.Id, options?: EditorRouter.NavigateOptions): Promise<void>;
+    navigateToUsers(options?: EditorRouter.NavigateOptions): Promise<void>;
+    navigateToDevtools(): Promise<void>;
+    private navigateTo;
+}
+export declare namespace EditorRouter {
+    type NavigateOptions = {
+        mode?: NavigateMode;
+    };
+    type NavigateMode = 'push' | 'replace' | 'new';
+    type Target = 'login' | 'login-reset' | 'auth' | 'dashboard' | 'templates' | 'pages' | 'page' | 'collections' | 'collection.items' | 'collection' | 'changesets' | 'changeset' | 'users' | 'devtools';
+    namespace Target {
+        const values: ReadonlyArray<Target>;
+        function filter(value: any): value is Target;
+        function coerce(value: any): Target | undefined;
+    }
+    type Link<T extends Route> = Omit<T, 'target'>;
+    namespace Link {
+        type Collection = Link<Route.Collection>;
+    }
+    type Route = Route.Login | Route.LoginReset | Route.Authenticate | Route.Dashboard | Route.Templates | Route.Pages | Route.Page | Route.Collections | Route.CollectionItems | Route.Collection | Route.ChangeSets | Route.ChangeSet | Route.Users | Route.Devtools;
+    namespace Route {
+        interface Base<T extends Target> {
+            target: T;
+        }
+        export interface Login extends Base<'login'> {
+        }
+        export interface LoginReset extends Base<'login-reset'> {
+        }
+        export interface Authenticate extends Base<'auth'> {
+        }
+        export interface Dashboard extends Base<'dashboard'> {
+        }
+        export interface Templates extends Base<'templates'> {
+            region: string;
+        }
+        export interface Pages extends Base<'pages'> {
+            region: string;
+            page: Schema.Page.Type;
+        }
+        export interface Page extends Base<'page'> {
+            region: string;
+            language: Language;
+            page: Schema.Page.Type;
+            slug?: string;
+        }
+        export interface Collections extends Base<'collections'> {
+        }
+        export interface CollectionItems extends Base<'collection.items'> {
+            type: Schema.Collection.Type;
+        }
+        export interface Collection extends Base<'collection'> {
+            type: Schema.Collection.Type;
+            language: Language;
+            groupId: Schema.Collection.GroupId;
+        }
+        export interface ChangeSets extends Base<'changesets'> {
+        }
+        export interface ChangeSet extends Base<'changeset'> {
+            changeSetId: Schema.ChangeSet.Id;
+        }
+        export interface Users extends Base<'users'> {
+        }
+        export interface Devtools extends Base<'devtools'> {
+        }
+        export function toPath(route: EditorRouter.Route, query?: Record<string, string | string[] | undefined>): string;
+        export {};
+    }
+    type Routes = Readonly<Record<EditorRouter.Target, Path | RouteAdapter>>;
+    type Path = string;
+    interface RouteAdapter<TRoute extends Route = Route> {
+        toRoute(pathComponents: string[], query: Record<string, string | string[] | undefined>): TRoute | undefined;
+        toPath(route: TRoute, query?: Record<string, string | string[] | undefined>): string;
+    }
+    namespace RouteAdapter {
+        function filter(value: Path | RouteAdapter): value is RouteAdapter;
+    }
+    const basePath = "/editor";
+    const routes: Routes;
+}

package/dist/core/routing/useEditorRouter.js

@@ -0,0 +1,399 @@
+"use strict";
+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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditorRouter = void 0;
+exports.useEditorRouter = useEditorRouter;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const router_1 = require("next/router");
+const qs_1 = __importDefault(require("qs"));
+const react_1 = require("react");
+const auth_1 = require("../auth");
+// hook
+function useEditorRouter() {
+    // bind router and return it
+    const nextRouter = (0, router_1.useRouter)();
+    const authenticator = (0, auth_1.useAuthenticator)();
+    return (0, react_1.useMemo)(() => new EditorRouter(nextRouter, authenticator), [nextRouter, authenticator]);
+}
+// router instance
+class EditorRouter {
+    constructor(_nextRouter, _authenticator) {
+        this._nextRouter = _nextRouter;
+        this._authenticator = _authenticator;
+        // initialize instance variables
+        const regionsConfig = funnel_core_1.AppConfig.brandConfig().regionalization;
+        this.regions = Object.keys(regionsConfig.regions);
+        this.includesRegions = this.regions.length > 1;
+    }
+    get ready() {
+        return this._nextRouter.isReady && this._authenticator.state !== 'unknown';
+    }
+    get region() {
+        // use default region if site is a single region
+        const regions = funnel_core_1.RegionsConfig.getRegions(funnel_core_1.AppConfig.brandConfig().regionalization);
+        if (regions.length === 1) {
+            return regions[0];
+        }
+        // or try to extract from route
+        const { route } = this;
+        switch (route === null || route === void 0 ? void 0 : route.target) {
+            case 'templates':
+            case 'pages':
+            case 'page':
+                return regions.find(region => region.id === route.region);
+            default:
+                return undefined;
+        }
+    }
+    get route() {
+        var _a;
+        // skip if not ready
+        if (!this.ready) {
+            return undefined;
+        }
+        // use cached route (if already parsed)
+        const { _nextRouter, _cachedRoute } = this;
+        const nextRouteQuery = _nextRouter.query;
+        if (_cachedRoute && funnel_core_1.Value.equals(_cachedRoute.query, nextRouteQuery)) {
+            return _cachedRoute.route;
+        }
+        // parse path into components
+        const _b = _nextRouter.query, { path: pathComponentsRaw = [] } = _b, query = __rest(_b, ["path"]);
+        const components = normalizePath(pathComponentsRaw).split('/');
+        const componentCount = components.length;
+        // find match
+        for (const [target, routePath] of Object.entries(EditorRouter.routes)) {
+            // handle case where path is an adapter
+            if (EditorRouter.RouteAdapter.filter(routePath)) {
+                // try to parse route
+                const route = routePath.toRoute(components.slice(1), query);
+                // return route if the path is valid
+                if (route) {
+                    // cache route
+                    this._cachedRoute = {
+                        query: nextRouteQuery,
+                        route
+                    };
+                    // return route
+                    return route;
+                }
+            }
+            // or handle basic path
+            else {
+                // skip if components don't have same length
+                const routeComponents = routePath.split('/');
+                if (routeComponents.length !== componentCount) {
+                    continue;
+                }
+                // match targets (or skip if it's not a match)
+                const params = {};
+                let match = true;
+                for (let i = 0; i < routeComponents.length; ++i) {
+                    // get next components to match
+                    const component = components[i];
+                    const routeComponent = routeComponents[i];
+                    // extract param from route (if it's an actual param)
+                    const [, param] = (_a = routeComponent.match(variableRegex)) !== null && _a !== void 0 ? _a : [];
+                    if (param) {
+                        params[param] = component;
+                    }
+                    // or stop if components don't match
+                    else if (routeComponent !== component) {
+                        match = false;
+                        break;
+                    }
+                }
+                // return route if we're a match, or just keep trying other routes
+                if (match) {
+                    // create route
+                    const route = Object.assign({ target }, params);
+                    // cache it
+                    this._cachedRoute = {
+                        query: nextRouteQuery,
+                        route
+                    };
+                    // and return it
+                    return route;
+                }
+            }
+        }
+        // we didn't match if we make it here
+        this._cachedRoute = {
+            query: nextRouteQuery,
+            route: undefined
+        };
+        return undefined;
+    }
+    reload() {
+        this._nextRouter.reload();
+    }
+    async navigateToLogin(options) {
+        // get current path context
+        const { _nextRouter } = this;
+        const _a = _nextRouter.query, { path: pathComponentsRaw = [] } = _a, query = __rest(_a, ["path"]);
+        const pathComponents = pathComponentsRaw.map(c => c.trim());
+        const currentPath = normalizePath(pathComponents);
+        // determine path (include a redirect back to where we are IF we're not coming from authentication)
+        const authPath = EditorRouter.Route.toPath({ target: 'auth' });
+        const routePath = currentPath !== authPath
+            ? EditorRouter.Route.toPath({ target: 'login' }, Object.assign(Object.assign({}, query), { redirect: currentPath }))
+            : EditorRouter.Route.toPath({ target: 'login' });
+        // navigate
+        await this.navigateTo(routePath, options);
+    }
+    async navigateToLoginReset(options) {
+        // determine route
+        const routePath = EditorRouter.Route.toPath({ target: 'login-reset' });
+        // navigate
+        await this.navigateTo(routePath, options);
+    }
+    async navigateToDashboard(options) {
+        // determine route
+        const routePath = EditorRouter.Route.toPath({ target: 'dashboard' });
+        // navigate
+        await this.navigateTo(routePath, options);
+    }
+    async navigateToTemplates(target, options) {
+        // determine route
+        const routePath = EditorRouter.Route.toPath(Object.assign({ target: 'templates' }, target));
+        // navigate
+        await this.navigateTo(routePath, options);
+    }
+    async navigateToPages(target, options) {
+        // determine route
+        const routePath = EditorRouter.Route.toPath(Object.assign({ target: 'pages' }, target));
+        // navigate
+        await this.navigateTo(routePath, options);
+    }
+    async navigateToPage(target, options) {
+        // determine route
+        const routePath = EditorRouter.Route.toPath(Object.assign({ target: 'page' }, target));
+        // navigate
+        await this.navigateTo(routePath, options);
+    }
+    async navigateToCollections(options) {
+        // determine route
+        const routePath = EditorRouter.Route.toPath({ target: 'collections' });
+        // navigate
+        await this.navigateTo(routePath, options);
+    }
+    async navigateToCollectionItems(target, options) {
+        // determine route
+        const routePath = EditorRouter.Route.toPath(Object.assign({ target: 'collection.items' }, target));
+        // navigate
+        await this.navigateTo(routePath, options);
+    }
+    async navigateToCollection(target, options) {
+        // determine route
+        const routePath = EditorRouter.Route.toPath(Object.assign({ target: 'collection' }, target));
+        // navigate
+        await this.navigateTo(routePath, options);
+    }
+    async navigateToChangeSets(options) {
+        // determine route
+        const routePath = EditorRouter.Route.toPath({ target: 'changesets' });
+        // navigate
+        await this.navigateTo(routePath, options);
+    }
+    async navigateToChangeSet(changeSetId, options) {
+        // determine route
+        const routePath = EditorRouter.Route.toPath({ target: 'changeset', changeSetId });
+        // navigate
+        await this.navigateTo(routePath, options);
+    }
+    async navigateToUsers(options) {
+        // determine route
+        const routePath = EditorRouter.Route.toPath({ target: 'users' });
+        // navigate
+        await this.navigateTo(routePath, options);
+    }
+    async navigateToDevtools() {
+        // determine route
+        const routePath = EditorRouter.Route.toPath({ target: 'devtools' });
+        // navigate
+        await this.navigateTo(routePath);
+    }
+    async navigateTo(path, { mode = 'push' } = {}) {
+        // push if requested
+        const { _nextRouter } = this;
+        switch (mode) {
+            case 'new': {
+                // open new tab
+                const url = new URL(path, window.location.href);
+                const tab = window.open(url, '_blank', 'noopener, noreferrer');
+                tab === null || tab === void 0 ? void 0 : tab.focus();
+                // stop
+                break;
+            }
+            case 'push':
+                await _nextRouter.push(path);
+                break;
+            case 'replace':
+                await _nextRouter.replace(path);
+                break;
+        }
+    }
+}
+exports.EditorRouter = EditorRouter;
+// extension
+(function (EditorRouter) {
+    let Target;
+    (function (Target) {
+        // constants
+        Target.values = [
+            'login', 'login-reset', 'auth',
+            'dashboard',
+            'templates', 'pages', 'page',
+            'collections', 'collection.items', 'collection',
+            'changesets', 'changeset',
+            'users',
+            'devtools'
+        ];
+        // helpers
+        function filter(value) {
+            return !!value && typeof value === 'string' && Target.values.includes(value);
+        }
+        Target.filter = filter;
+        function coerce(value) {
+            // skip if value isn't defined
+            if (!!value || typeof value !== 'string') {
+                return undefined;
+            }
+            // return based on filtering
+            const target = value.toLowerCase().trim();
+            return filter(target) ? target : undefined;
+        }
+        Target.coerce = coerce;
+    })(Target = EditorRouter.Target || (EditorRouter.Target = {}));
+    let Route;
+    (function (Route) {
+        // methods
+        function toPath(route, query) {
+            var _a;
+            //  use adapter if it's not path
+            let routePath = EditorRouter.routes[route.target];
+            if (RouteAdapter.filter(routePath)) {
+                return routePath.toPath(route);
+            }
+            // get route path
+            const routeData = route;
+            const routeComponents = routePath.split('/');
+            for (let i = 0; i < routeComponents.length; ++i) {
+                // replace params with values from the route
+                const routeComponent = routeComponents[i];
+                const [, param] = (_a = routeComponent.match(variableRegex)) !== null && _a !== void 0 ? _a : [];
+                if (param && routeData[param] !== undefined) {
+                    routeComponents[i] = routeData[param];
+                }
+            }
+            // update path
+            routePath = routeComponents.join('/');
+            // create query (if any)
+            const queryParams = query ? '' : qs_1.default.stringify(query);
+            // return path (with query, if provided)
+            const normalizedPath = normalizePath(routePath);
+            const editorPath = normalizedPath.startsWith(EditorRouter.basePath)
+                ? normalizedPath
+                : EditorRouter.basePath + normalizedPath;
+            return queryParams.length > 0
+                ? `${editorPath}?${queryParams}`
+                : editorPath;
+        }
+        Route.toPath = toPath;
+    })(Route = EditorRouter.Route || (EditorRouter.Route = {}));
+    let RouteAdapter;
+    (function (RouteAdapter) {
+        function filter(value) {
+            return typeof value !== 'string';
+        }
+        RouteAdapter.filter = filter;
+    })(RouteAdapter = EditorRouter.RouteAdapter || (EditorRouter.RouteAdapter = {}));
+    // constants
+    EditorRouter.basePath = '/editor';
+    EditorRouter.routes = {
+        login: '/login',
+        'login-reset': '/login/reset',
+        auth: '/auth',
+        dashboard: '',
+        templates: '/pages/[region]',
+        pages: '/pages/[region]/[page]',
+        // '/page/[region]/[page]/[language]' OR '/page/[region]/[page]/[slug]/[language]'
+        page: {
+            toRoute: (pathComponents) => {
+                // skip if it's not a page
+                const [target, region, rawPage, ...slugOrLanguage] = pathComponents;
+                if (target !== 'page') {
+                    return undefined;
+                }
+                // handle dynamic page if it matches (fail if language isn't a language)
+                const page = rawPage;
+                if (pathComponents.length === 5) {
+                    const [slug, language] = slugOrLanguage;
+                    return funnel_core_1.Language.filter(language)
+                        ? { target: 'page', region, page, slug, language }
+                        : undefined;
+                }
+                // or handle static page (fail if language isn't a language)
+                else if (pathComponents.length === 4) {
+                    const [language] = slugOrLanguage;
+                    return funnel_core_1.Language.filter(language)
+                        ? { target: 'page', region, page, language }
+                        : undefined;
+                }
+                // otherwise it's not a match
+                else {
+                    return undefined;
+                }
+            },
+            toPath: ({ region, page, slug, language }) => {
+                return slug
+                    ? `${EditorRouter.basePath}/page/${region}/${page}/${slug}/${language}`
+                    : `${EditorRouter.basePath}/page/${region}/${page}/${language}`;
+            }
+        },
+        collections: '/collections',
+        'collection.items': '/collections/[type]',
+        collection: '/collections/[type]/[groupId]/[language]',
+        changesets: '/changes',
+        changeset: '/change/[changeSetId]',
+        users: '/users',
+        devtools: '/devtools'
+    };
+})(EditorRouter || (exports.EditorRouter = EditorRouter = {}));
+const variableRegex = /^\[(\w+)]$/;
+function normalizePath(path) {
+    // handle empty path
+    let normalizedPath;
+    if (!path) {
+        normalizedPath = '';
+    }
+    // group array components
+    else if (Array.isArray(path)) {
+        normalizedPath = path.join('/');
+    }
+    // assign basic string
+    else {
+        normalizedPath = path === '/'
+            ? ''
+            : path;
+    }
+    // prefix with "/" if required
+    if (normalizedPath.length > 0 && !normalizedPath.startsWith('/')) {
+        normalizedPath = '/' + normalizedPath;
+    }
+    // return normalized path
+    return normalizedPath;
+}

package/dist/core/screens/NotFound.d.ts

@@ -0,0 +1 @@
+export declare function NotFound(): import("react/jsx-runtime").JSX.Element;

package/dist/core/screens/NotFound.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFound = NotFound;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const link_1 = __importDefault(require("next/link"));
+// page
+function NotFound() {
+    return ((0, jsx_runtime_1.jsxs)("div", { children: ["Not found... go ", (0, jsx_runtime_1.jsx)(link_1.default, { href: "/editor", children: "Home" }), "."] }));
+}

package/dist/core/screens/index.d.ts

@@ -0,0 +1 @@
+export * from './NotFound';

package/dist/core/screens/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./NotFound"), exports);