@rxdi/router 0.7.219 → 0.7.221

package/dist/lib/triggers.d.ts

@@ -0,0 +1,6 @@
+import { NavigationTrigger } from './types';
+export declare function RouterGlobalClickHandler(event: MouseEvent): void;
+export declare const CLICK: NavigationTrigger;
+export declare function RouterGlobalPopstateHandler(event: PopStateEvent): void;
+export declare const POPSTATE: NavigationTrigger;
+export declare function setNavigationTriggers(newTriggers: NavigationTrigger[]): void;

package/dist/lib/triggers.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POPSTATE = exports.CLICK = void 0;
+exports.RouterGlobalClickHandler = RouterGlobalClickHandler;
+exports.RouterGlobalPopstateHandler = RouterGlobalPopstateHandler;
+exports.setNavigationTriggers = setNavigationTriggers;
+const utils_1 = require("./utils");
+// IE Polyfill for PopStateEvent
+const isIE = /Trident/.test(navigator.userAgent);
+if (isIE && !(0, utils_1.isFunction)(window.PopStateEvent)) {
+    window.PopStateEvent = function (inType, params) {
+        params = params || {};
+        const e = document.createEvent('Event');
+        e.initEvent(inType, Boolean(params.bubbles), Boolean(params.cancelable));
+        e.state = params.state || null;
+        return e;
+    };
+    window.PopStateEvent.prototype = window.Event
+        .prototype;
+}
+function RouterGlobalClickHandler(event) {
+    if (event.defaultPrevented) {
+        return;
+    }
+    if (event.button !== 0) {
+        return;
+    }
+    if (event.shiftKey || event.ctrlKey || event.altKey || event.metaKey) {
+        return;
+    }
+    let anchor = event.target;
+    const path = event.composedPath
+        ? event.composedPath()
+        : event.path || [];
+    for (let i = 0; i < path.length; i++) {
+        const target = path[i];
+        if (target.nodeName && target.nodeName.toLowerCase() === 'a') {
+            anchor = target;
+            break;
+        }
+    }
+    while (anchor && anchor.nodeName && anchor.nodeName.toLowerCase() !== 'a') {
+        anchor = anchor.parentNode;
+    }
+    if (!anchor || anchor.nodeName.toLowerCase() !== 'a') {
+        return;
+    }
+    const anchorElement = anchor;
+    if (anchorElement.target && anchorElement.target.toLowerCase() !== '_self') {
+        return;
+    }
+    if (anchorElement.hasAttribute('download')) {
+        return;
+    }
+    if (anchorElement.hasAttribute('router-ignore')) {
+        return;
+    }
+    if (anchorElement.pathname === window.location.pathname && anchorElement.hash !== '') {
+        return;
+    }
+    const origin = anchorElement.origin || (0, utils_1.getAnchorOrigin)(anchorElement);
+    if (origin !== window.location.origin) {
+        return;
+    }
+    const { pathname, search, hash } = anchorElement;
+    if ((0, utils_1.fireRouterEvent)('go', { pathname, search, hash })) {
+        event.preventDefault();
+    }
+}
+exports.CLICK = {
+    activate() {
+        window.document.addEventListener('click', RouterGlobalClickHandler);
+    },
+    inactivate() {
+        window.document.removeEventListener('click', RouterGlobalClickHandler);
+    },
+};
+function RouterGlobalPopstateHandler(event) {
+    if (event.state === 'router-ignore') {
+        return;
+    }
+    const { pathname, search, hash } = window.location;
+    (0, utils_1.fireRouterEvent)('go', { pathname, search, hash });
+}
+exports.POPSTATE = {
+    activate() {
+        window.addEventListener('popstate', RouterGlobalPopstateHandler);
+    },
+    inactivate() {
+        window.removeEventListener('popstate', RouterGlobalPopstateHandler);
+    },
+};
+let triggers = [];
+function setNavigationTriggers(newTriggers) {
+    triggers.forEach((trigger) => trigger.inactivate());
+    newTriggers.forEach((trigger) => trigger.activate());
+    triggers = newTriggers;
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,134 @@
+import { Router } from '.';
+import { Resolver } from './resolver';
+export interface RouteParams {
+    [key: string]: string | string[];
+}
+export interface ChainItem {
+    path: string;
+    route: Route;
+    element?: HTMLElement;
+}
+export interface RouteContext {
+    pathname: string;
+    search?: string;
+    hash?: string;
+    params: RouteParams;
+    keys: PathToken[];
+    route: Route;
+    chain?: ChainItem[];
+    result?: RouteResult;
+    next?: (resume?: boolean, parent?: Route, prevResult?: RouteResult | null) => Promise<RouteContext | typeof notFoundResult>;
+    resolver?: Resolver;
+    redirectFrom?: string;
+    __renderId?: number;
+    __redirectCount?: number;
+    __divergedChainIndex?: number;
+    __skipAttach?: boolean;
+}
+export interface RouterLocation {
+    baseUrl: string;
+    pathname: string;
+    search: string;
+    hash: string;
+    routes: Route[];
+    route: Route | null;
+    params: RouteParams;
+    redirectFrom?: string;
+    getUrl: (userParams?: RouteParams) => string;
+}
+export interface RouteCommands {
+    redirect: (path: string) => RedirectResult;
+    component: (component: string) => HTMLElement;
+}
+export type RouteAction = (context: RouteContext, commands?: RouteCommands) => RouteResult | Promise<RouteResult> | undefined | Promise<undefined>;
+export type RouteChildren = Route[] | ((context: Omit<RouteContext, 'next'>) => Route[] | Promise<Route[]>);
+export interface RouteBundle {
+    module?: string;
+    nomodule?: string;
+}
+export interface Route {
+    path?: string | string[];
+    name?: string;
+    component?: string;
+    redirect?: string;
+    bundle?: string | RouteBundle;
+    action?: RouteAction;
+    children?: RouteChildren;
+    animate?: boolean | {
+        leave?: string;
+        enter?: string;
+    };
+    parent?: Route | null;
+    __children?: Route[] | RouteChildren | undefined;
+    __synthetic?: boolean;
+    fullPath?: string;
+}
+export type RouteResult = HTMLElement | RedirectResult | Error | typeof notFoundResult | null | undefined;
+export interface RedirectResult {
+    redirect: {
+        pathname: string;
+        from: string;
+        params: RouteParams;
+    };
+}
+export interface PreventResult {
+    cancel: boolean;
+}
+export interface ResolverOptions {
+    baseUrl?: string;
+    errorHandler?: (error: Error) => RouteResult;
+    resolveRoute?: (context: RouteContext) => RouteResult | Promise<RouteResult> | undefined | Promise<undefined>;
+    context?: Partial<RouteContext>;
+}
+export type RouterOptions = ResolverOptions;
+export interface NavigationTrigger {
+    activate: () => void;
+    inactivate: () => void;
+}
+export interface PathToken {
+    name: string | number;
+    prefix: string;
+    delimiter: string;
+    optional: boolean;
+    repeat: boolean;
+    partial: boolean;
+    pattern: string;
+}
+export interface PathRegexp {
+    keys: PathToken[];
+    pattern: RegExp;
+}
+export interface MatchResult {
+    path: string;
+    keys: PathToken[];
+    params: RouteParams;
+    route?: Route;
+}
+export interface PathToRegexpOptions {
+    sensitive?: boolean;
+    strict?: boolean;
+    end?: boolean;
+    start?: boolean;
+    delimiter?: string;
+    endsWith?: string | string[];
+    delimiters?: string;
+}
+export interface CompileOptions {
+    encode?: (value: string, token: PathToken) => string;
+}
+export interface MatchIterator {
+    next: (routeToSkip?: Route) => IteratorResult<MatchResult, undefined>;
+}
+export type UrlGenerator = (routeName: string, params?: RouteParams) => string;
+export interface GenerateUrlsOptions {
+    encode?: (value: string, token: PathToken) => string;
+    stringifyQueryParams?: (params: Record<string, unknown>) => string;
+}
+export interface HTMLElementWithLocation extends HTMLElement {
+    location?: RouterLocation;
+    onBeforeEnter?: (location: RouterLocation, commands: Record<string, unknown>, router: Router) => PreventResult | RedirectResult | void | Promise<PreventResult | RedirectResult | void>;
+    onBeforeLeave?: (location: RouterLocation, commands: Record<string, unknown>, router: Router) => PreventResult | RedirectResult | void | Promise<PreventResult | RedirectResult | void>;
+    onAfterEnter?: (location: RouterLocation, commands: Record<string, unknown>, resolver: Resolver) => void;
+    onAfterLeave?: (location: RouterLocation, commands: Record<string, unknown>, resolver: Resolver) => void;
+}
+export declare const notFoundResult: {};

package/dist/lib/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notFoundResult = void 0;
+// TODO: Move this to a better place or import it
+exports.notFoundResult = new (class NotFoundResult {
+})();

package/dist/lib/utils.d.ts

@@ -0,0 +1,20 @@
+import { Router } from './router';
+import { Route, RouteBundle, RouteContext } from './types';
+export declare function toArray<T>(objectOrArray: T | T[]): T[];
+export declare function log(msg: string): string;
+export declare function logValue(value: unknown): string;
+export declare function ensureBundle(src: string): void;
+export declare function isObject(o: unknown): o is Record<string, unknown>;
+export declare function isFunction(f: unknown): f is Function;
+export declare function isString(s: unknown): s is string;
+export declare function ensureRoute(route: Route): void;
+export declare function ensureRoutes(routes: Route | Route[]): void;
+export declare function loadScript(src: string, key?: string): Promise<Event | void>;
+export declare function loadBundle(bundle: string | RouteBundle): Promise<void>;
+export declare function fireRouterEvent(type: string, detail: Partial<HTMLAnchorElement> | Partial<Location> | Partial<Router>): boolean;
+export declare function getNotFoundError(context: RouteContext): Error & {
+    context: RouteContext;
+    code: number;
+};
+export declare function getAnchorOrigin(anchor: HTMLAnchorElement): string;
+export declare function runCallbackIfPossible<T extends unknown[], R>(callback: ((...args: T) => R) | undefined, args: T, thisArg: unknown): R | undefined;

package/dist/lib/utils.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toArray = toArray;
+exports.log = log;
+exports.logValue = logValue;
+exports.ensureBundle = ensureBundle;
+exports.isObject = isObject;
+exports.isFunction = isFunction;
+exports.isString = isString;
+exports.ensureRoute = ensureRoute;
+exports.ensureRoutes = ensureRoutes;
+exports.loadScript = loadScript;
+exports.loadBundle = loadBundle;
+exports.fireRouterEvent = fireRouterEvent;
+exports.getNotFoundError = getNotFoundError;
+exports.getAnchorOrigin = getAnchorOrigin;
+exports.runCallbackIfPossible = runCallbackIfPossible;
+const constants_1 = require("./constants");
+function toArray(objectOrArray) {
+    objectOrArray = objectOrArray || [];
+    return Array.isArray(objectOrArray) ? objectOrArray : [objectOrArray];
+}
+function log(msg) {
+    return `[Router] ${msg}`;
+}
+function logValue(value) {
+    if (typeof value !== 'object') {
+        return String(value);
+    }
+    const stringType = Object.prototype.toString.call(value).match(/ (.*)\]$/)[1];
+    if (stringType === 'Object' || stringType === 'Array') {
+        return `${stringType} ${JSON.stringify(value)}`;
+    }
+    else {
+        return stringType;
+    }
+}
+function ensureBundle(src) {
+    if (!src.match(/.+\.[m]?js$/)) {
+        throw new Error(log(`Unsupported type for bundle "${src}": .js or .mjs expected.`));
+    }
+}
+function isObject(o) {
+    return typeof o === 'object' && !!o;
+}
+function isFunction(f) {
+    return typeof f === 'function';
+}
+function isString(s) {
+    return typeof s === 'string';
+}
+function ensureRoute(route) {
+    if (!route || !isString(route.path)) {
+        throw new Error(log(`Expected route config to be an object with a "path" string property, or an array of such objects`));
+    }
+    const bundle = route.bundle;
+    const stringKeys = ['component', 'redirect', 'bundle'];
+    if (!isFunction(route.action) &&
+        !Array.isArray(route.children) &&
+        !isFunction(route.children) &&
+        !isObject(bundle) &&
+        !stringKeys.some((key) => isString(route[key]))) {
+        throw new Error(log(`Expected route config "${route.path}" to include either "${stringKeys.join('", "')}" ` +
+            `or "action" function but none found.`));
+    }
+    if (bundle) {
+        if (isString(bundle)) {
+            ensureBundle(bundle);
+        }
+        else if (!constants_1.bundleKeys.some((key) => key in bundle)) {
+            throw new Error(log('Expected route bundle to include either "' + constants_1.NOMODULE + '" or "' + constants_1.MODULE + '" keys, or both'));
+        }
+        else {
+            constants_1.bundleKeys.forEach((key) => key in bundle && ensureBundle(bundle[key]));
+        }
+    }
+    if (route.redirect) {
+        ['bundle', 'component'].forEach((overriddenProp) => {
+            if (overriddenProp in route) {
+                console.warn(log(`Route config "${route.path}" has both "redirect" and "${overriddenProp}" properties, ` +
+                    `and "redirect" will always override the latter. Did you mean to only use "${overriddenProp}"?`));
+            }
+        });
+    }
+}
+function ensureRoutes(routes) {
+    toArray(routes).forEach((route) => ensureRoute(route));
+}
+function loadScript(src, key) {
+    let script = document.head.querySelector('script[src="' + src + '"][async]');
+    if (!script) {
+        script = document.createElement('script');
+        script.setAttribute('src', src);
+        if (key === constants_1.MODULE) {
+            script.setAttribute('type', constants_1.MODULE);
+        }
+        else if (key === constants_1.NOMODULE) {
+            script.setAttribute(constants_1.NOMODULE, '');
+        }
+        script.async = true;
+    }
+    return new Promise((resolve, reject) => {
+        script['onreadystatechange'] = script.onload = (e) => {
+            script.__dynamicImportLoaded = true;
+            resolve(e);
+        };
+        script.onerror = (e) => {
+            if (script.parentNode) {
+                script.parentNode.removeChild(script);
+            }
+            reject(e);
+        };
+        if (script.parentNode === null) {
+            document.head.appendChild(script);
+        }
+        else if (script.__dynamicImportLoaded) {
+            resolve();
+        }
+    });
+}
+function loadBundle(bundle) {
+    if (isString(bundle)) {
+        return loadScript(bundle).then(() => {
+            //
+        });
+    }
+    else {
+        return Promise.race(constants_1.bundleKeys.filter((key) => key in bundle).map((key) => loadScript(bundle[key], key))).then(() => {
+            //
+        });
+    }
+}
+function fireRouterEvent(type, detail) {
+    return !window.dispatchEvent(new CustomEvent(`router-${type}`, { cancelable: type === 'go', detail }));
+}
+function getNotFoundError(context) {
+    const error = new Error(log(`Page not found (${context.pathname})`));
+    error.context = context;
+    error.code = 404;
+    return error;
+}
+function getAnchorOrigin(anchor) {
+    const port = anchor.port;
+    const protocol = anchor.protocol;
+    const defaultHttp = protocol === 'http:' && port === '80';
+    const defaultHttps = protocol === 'https:' && port === '443';
+    const host = defaultHttp || defaultHttps ? anchor.hostname : anchor.host;
+    return `${protocol}//${host}`;
+}
+function runCallbackIfPossible(callback, args, thisArg) {
+    if (isFunction(callback)) {
+        return callback.apply(thisArg, args);
+    }
+    return undefined;
+}

package/dist/not-found.component.js

@@ -15,9 +15,9 @@ exports.NotFoundComponent = NotFoundComponent = __decorate([
     (0, lit_html_1.Component)({
         selector: 'not-found-component-rxdi',
         template: () => (0, lit_html_1.html) `
-  <h1>Not found component!</h1>
-  <p>Please check your URL.2222daad</p>
- `,
+    <h1>Not found component!</h1>
+    <p>Please check your URL.2222daad</p>
+  `,
     })
 ], NotFoundComponent);
 exports.NotFoundPathConfig = {

package/dist/outlet.d.ts

@@ -1,5 +1,6 @@
-import { Router as VaadinRouter } from './vaadin/vaadin-router';
-import { RouterOptions, Route } from './injection.tokens';
+import { Observable } from 'rxjs';
+import { RouterOptions } from './injection.tokens';
+import { Router } from './lib';
 interface Detail extends Event {
     detail: {
         location: {
@@ -7,81 +8,25 @@ interface Detail extends Event {
         };
     };
 }
-export declare class Outlet<C = {}> extends VaadinRouter {
+export declare class Outlet extends Router {
     private options;
     activePath: string;
     private freeze;
-    private listener;
+    private subscription;
     constructor(element: Element, options: RouterOptions);
-    onSnapshotChange(callback: (event: Detail) => void): {
-        unsubscribe: () => void;
-    };
+    onSnapshotChange(): Observable<Detail>;
     freezeRouter(): void;
     unfreezeRouter(): void;
     getQueryParams<T>(params: string[]): T;
     /**
-     * Takes current routes and set it
-     * @param routes: Route<C>[]
-     * @returns Route<C>[]
-     */
-    setRoutes(routes: Route<C>[]): Promise<Node>;
-    /**
-     * Takes current routes and set it
-     * @param routes: Route<C>[]
-     * @returns void
-     */
-    setOutlet(outlet: Node): void;
-    /**
-     * Triggers navigation to a new path. Returns a boolean without waiting until the navigation is complete. Returns true if at least one Vaadin.Router has handled the navigation (was subscribed and had baseUrl matching the pathname argument), otherwise returns false.
+     * Triggers navigation to a new path. Returns a boolean without waiting until the navigation is complete. Returns true if at least one Router has handled the navigation (was subscribed and had baseUrl matching the pathname argument), otherwise returns false.
      * @param pathnamea new in-app path
      * @returns void
      */
     go(path: string): boolean;
-    /**
-     * Vaadin Router supports refferring to routes using string names. You can assign a name to a route using the name property of a route object, then generate URLs for that route using the router.urlForName(name, parameters) helper instance method.
-     * @param name — the route name
-     * @param parameters — optional object with parameters for substitution in the route path
-     */
-    urlForName(url: string, params: any): string;
-    /**
-     * router.urlForPath(path, parameters) is a helper method that generates a URL for the given route path, optionally performing substitution of parameters.
-     * @param path — a string route path defined in express.js syntax
-     * @param parameters — optional object with parameters for path substitution
-     */
-    urlForPath(path: string, params: any): string;
-    /**
-     * Returns the current router outlet. The initial value is undefined.
-     */
-    getOutlet(): Node;
-    /**
-     * Inherited from Vaadin.Resolver Returns the current list of routes (as a shallow copy). Adding / removing routes to / from the returned array does not affect the routing config, but modifying the route objects does.
-     */
-    getRoutes(): Route<C>[];
-    /**
-     * Removes all existing routes from the routing config.
-     */
-    removeRoutes(): void;
-    /**
-     * Asynchronously resolves the given pathname and renders the resolved route component into the router outlet. If no router outlet is set at the time of calling this method, or at the time when the route resolution is completed, a TypeError is thrown.
-     * Returns a promise that is fulfilled with the router outlet DOM Node after the route component is created and inserted into the router outlet, or rejected if no route matches the given path.
-     * If another render pass is started before the previous one is completed, the result of the previous render pass is ignored.
-     * @param pathnameOrContext — the pathname to render or a context object with a pathname property and other properties to pass to the resolver.
-     * @param shouldUpdateHistory
-     */
-    render(pathnameOrContext: string | {
-        pathname: string;
-        search: string;
-        hash: string;
-    }, shouldUpdateHistory: any): Promise<Node>;
-    /**
-     * Subscribes this instance to navigation events on the window.
-     * NOTE: beware of resource leaks. For as long as a router instance is subscribed to navigation events, it won't be garbage collected.
-     */
-    subscribe(): void;
     /**
      * Removes the subscription to navigation events created in the subscribe() method.
      */
     unsubscribe(): void;
-    addRoutes(routes: Route<C> | Route<C>[]): Route<C>[];
 }
 export {};

package/dist/outlet.js

@@ -1,25 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Outlet = void 0;
-const vaadin_router_1 = require("./vaadin/vaadin-router");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
 const helpers_1 = require("./helpers");
-class Outlet extends vaadin_router_1.Router {
+const lib_1 = require("./lib");
+class Outlet extends lib_1.Router {
     constructor(element, options) {
         super(element, options);
         this.options = options;
         this.activePath = '/';
-        this.listener = this.onSnapshotChange((event) => {
+        this.subscription = this.onSnapshotChange()
+            .pipe((0, operators_1.tap)((event) => {
             if (this.options.log) {
                 console.log(`You are at '${event.detail.location.pathname}'`);
             }
             this.activePath = event.detail.location.pathname;
-        });
+        }))
+            .subscribe();
     }
-    onSnapshotChange(callback) {
-        window.addEventListener('vaadin-router-location-changed', callback);
-        return {
-            unsubscribe: () => window.removeEventListener('vaadin-router-location-changed', callback),
-        };
+    onSnapshotChange() {
+        return (0, rxjs_1.fromEvent)(window, 'router-location-changed');
     }
     freezeRouter() {
         this.freeze = true;
@@ -31,23 +32,7 @@ class Outlet extends vaadin_router_1.Router {
         return (0, helpers_1.getQueryParams)(params);
     }
     /**
-     * Takes current routes and set it
-     * @param routes: Route<C>[]
-     * @returns Route<C>[]
-     */
-    setRoutes(routes) {
-        return super.setRoutes(routes);
-    }
-    /**
-     * Takes current routes and set it
-     * @param routes: Route<C>[]
-     * @returns void
-     */
-    setOutlet(outlet) {
-        super.setOutlet(outlet);
-    }
-    /**
-     * Triggers navigation to a new path. Returns a boolean without waiting until the navigation is complete. Returns true if at least one Vaadin.Router has handled the navigation (was subscribed and had baseUrl matching the pathname argument), otherwise returns false.
+     * Triggers navigation to a new path. Returns a boolean without waiting until the navigation is complete. Returns true if at least one Router has handled the navigation (was subscribed and had baseUrl matching the pathname argument), otherwise returns false.
      * @param pathnamea new in-app path
      * @returns void
      */
@@ -59,71 +44,17 @@ class Outlet extends vaadin_router_1.Router {
         if (this.options.freeze) {
             this.freezeRouter();
         }
-        // window.dispatchEvent(new CustomEvent('vaadin-router-go', {detail: {pathname: '/to/path'}}));
-        return vaadin_router_1.Router.go(path);
-    }
-    /**
-     * Vaadin Router supports refferring to routes using string names. You can assign a name to a route using the name property of a route object, then generate URLs for that route using the router.urlForName(name, parameters) helper instance method.
-     * @param name — the route name
-     * @param parameters — optional object with parameters for substitution in the route path
-     */
-    urlForName(url, params) {
-        return super.urlForName(url, params);
-    }
-    /**
-     * router.urlForPath(path, parameters) is a helper method that generates a URL for the given route path, optionally performing substitution of parameters.
-     * @param path — a string route path defined in express.js syntax
-     * @param parameters — optional object with parameters for path substitution
-     */
-    urlForPath(path, params) {
-        return super.urlForPath(path, params);
-    }
-    /**
-     * Returns the current router outlet. The initial value is undefined.
-     */
-    getOutlet() {
-        return super.getOutlet();
-    }
-    /**
-     * Inherited from Vaadin.Resolver Returns the current list of routes (as a shallow copy). Adding / removing routes to / from the returned array does not affect the routing config, but modifying the route objects does.
-     */
-    getRoutes() {
-        return super.getRoutes();
-    }
-    /**
-     * Removes all existing routes from the routing config.
-     */
-    removeRoutes() {
-        super.removeRoutes();
-    }
-    /**
-     * Asynchronously resolves the given pathname and renders the resolved route component into the router outlet. If no router outlet is set at the time of calling this method, or at the time when the route resolution is completed, a TypeError is thrown.
-     * Returns a promise that is fulfilled with the router outlet DOM Node after the route component is created and inserted into the router outlet, or rejected if no route matches the given path.
-     * If another render pass is started before the previous one is completed, the result of the previous render pass is ignored.
-     * @param pathnameOrContext — the pathname to render or a context object with a pathname property and other properties to pass to the resolver.
-     * @param shouldUpdateHistory
-     */
-    render(pathnameOrContext, shouldUpdateHistory) {
-        return super.render(pathnameOrContext, shouldUpdateHistory);
-    }
-    /**
-     * Subscribes this instance to navigation events on the window.
-     * NOTE: beware of resource leaks. For as long as a router instance is subscribed to navigation events, it won't be garbage collected.
-     */
-    subscribe() {
-        super.subscribe();
+        // window.dispatchEvent(new CustomEvent('router-go', {detail: {pathname: '/to/path'}}));
+        return lib_1.Router.go(path);
     }
     /**
      * Removes the subscription to navigation events created in the subscribe() method.
      */
     unsubscribe() {
-        if (this.listener) {
-            this.listener.unsubscribe();
+        if (this.subscription) {
+            this.subscription.unsubscribe();
         }
         super.unsubscribe();
     }
-    addRoutes(routes) {
-        return super.addRoutes(routes);
-    }
 }
 exports.Outlet = Outlet;

package/dist/router.component.d.ts

@@ -1,10 +1,10 @@
-import { LitElement } from "@rxdi/lit-html";
-import { Route } from "./injection.tokens";
+import { LitElement } from '@rxdi/lit-html';
+import { Route } from './injection.tokens';
 /**
  * @customElement router-outlet
  */
 export declare class RouterComponent extends LitElement {
     id: string;
-    routes: Route[];
+    routes: Route | Route[];
     OnUpdateFirst(): void;
 }