@shuvi/router 0.0.1-pre.1 → 0.0.1-pre.2

package/esm/createRoutesFromArray.d.ts

@@ -0,0 +1,2 @@
+import { IPartialRouteRecord, IRouteRecord } from './types';
+export declare function createRoutesFromArray<T extends IPartialRouteRecord, U extends IRouteRecord>(array: T[]): U[];

package/esm/createRoutesFromArray.js

@@ -0,0 +1,9 @@
+export function createRoutesFromArray(array) {
+    return array.map(partialRoute => {
+        let route = Object.assign(Object.assign({}, partialRoute), { caseSensitive: !!partialRoute.caseSensitive, path: partialRoute.path || '/' });
+        if (partialRoute.children) {
+            route.children = createRoutesFromArray(partialRoute.children);
+        }
+        return route;
+    });
+}

package/esm/getRedirectFromRoutes.d.ts

@@ -0,0 +1,2 @@
+import { IRouteMatch, IRouteRecord } from './types';
+export declare function getRedirectFromRoutes<Route extends IRouteRecord>(appRoutes: IRouteMatch<Route>[]): string | null;

package/esm/getRedirectFromRoutes.js

@@ -0,0 +1,8 @@
+export function getRedirectFromRoutes(appRoutes) {
+    return appRoutes.reduceRight((redirectPath, { route: { redirect } }) => {
+        if (!redirectPath && redirect) {
+            return redirect;
+        }
+        return redirectPath;
+    }, null);
+}

package/esm/history/base.d.ts

@@ -0,0 +1,53 @@
+import { State, HistoryState, Blocker, Location, ResolvedPath, PathRecord, Action } from '../types';
+/**
+ * A POP indicates a change to an arbitrary index in the history stack, such
+ * as a back or forward navigation. It does not describe the direction of the
+ * navigation, only that the current index changed.
+ *
+ * Note: This is the default action for newly created history objects.
+ */
+export declare const ACTION_POP: Action;
+/**
+ * A Push indicates a new entry being added to the history stack, such as when
+ * a link is clicked and a new page loads. When this happens, all subsequent
+ * entries in the stack are lost.
+ */
+export declare const ACTION_PUSH: Action;
+/**
+ * A REPLACE indicates the entry at the current index in the history stack
+ * being replaced by a new one.
+ */
+export declare const ACTION_REPLACE: Action;
+export interface TransitionOptions {
+    state?: State;
+    action?: Action;
+    redirectedFrom?: PathRecord;
+    onTransition(event: {
+        location: Location;
+        state: HistoryState;
+        url: string;
+    }): void;
+    onAbort?(): void;
+}
+export interface PushOptions {
+    state?: object | null | undefined;
+    redirectedFrom?: PathRecord;
+}
+export default abstract class BaseHistory {
+    action: Action;
+    location: Location;
+    doTransition: (to: PathRecord, onComplete: Function, onAbort?: Function) => void;
+    protected _index: number;
+    protected _blockers: import("../utils").Events<Blocker<State>>;
+    protected abstract getIndexAndLocation(): [number, Location];
+    abstract setup(): void;
+    abstract push(to: PathRecord, options: PushOptions): void;
+    abstract replace(to: PathRecord, options?: PushOptions): void;
+    abstract go(delta: number): void;
+    abstract block(blocker: Blocker<State>): () => void;
+    back(): void;
+    forward(): void;
+    resolve(to: any, from?: any): ResolvedPath;
+    transitionTo(to: PathRecord, { onTransition, onAbort, action, state, redirectedFrom }: TransitionOptions): void;
+    private _updateState;
+}

package/esm/history/base.js

@@ -0,0 +1,80 @@
+import { createLocation, createEvents, resolvePath, pathToString } from '../utils';
+/**
+ * A POP indicates a change to an arbitrary index in the history stack, such
+ * as a back or forward navigation. It does not describe the direction of the
+ * navigation, only that the current index changed.
+ *
+ * Note: This is the default action for newly created history objects.
+ */
+export const ACTION_POP = 'POP';
+/**
+ * A Push indicates a new entry being added to the history stack, such as when
+ * a link is clicked and a new page loads. When this happens, all subsequent
+ * entries in the stack are lost.
+ */
+export const ACTION_PUSH = 'PUSH';
+/**
+ * A REPLACE indicates the entry at the current index in the history stack
+ * being replaced by a new one.
+ */
+export const ACTION_REPLACE = 'REPLACE';
+export default class BaseHistory {
+    constructor() {
+        this.action = ACTION_POP;
+        this.location = createLocation('/');
+        this.doTransition = () => void 0;
+        this._index = 0;
+        this._blockers = createEvents();
+    }
+    back() {
+        this.go(-1);
+    }
+    forward() {
+        this.go(1);
+    }
+    resolve(to, from) {
+        const toPath = resolvePath(to, from);
+        return {
+            path: toPath,
+            href: pathToString(toPath)
+        };
+    }
+    transitionTo(to, { onTransition, onAbort, action = ACTION_PUSH, state = null, redirectedFrom }) {
+        const { path } = this.resolve(to, this.location.pathname);
+        const nextLocation = createLocation(path, { state, redirectedFrom });
+        // check transition
+        if (this._blockers.length) {
+            this._blockers.call({
+                action,
+                location: nextLocation,
+                retry: () => {
+                    this.transitionTo(to, {
+                        onTransition,
+                        onAbort,
+                        action,
+                        state,
+                        redirectedFrom
+                    });
+                }
+            });
+            return;
+        }
+        this.doTransition(to, () => {
+            onTransition({
+                location: nextLocation,
+                state: {
+                    usr: nextLocation.state,
+                    key: nextLocation.key,
+                    idx: this._index + 1
+                },
+                url: this.resolve(nextLocation).href
+            });
+            this._updateState(action);
+        }, onAbort);
+    }
+    _updateState(nextAction) {
+        // update state
+        this.action = nextAction;
+        [this._index, this.location] = this.getIndexAndLocation();
+    }
+}

package/esm/history/browser.d.ts

@@ -0,0 +1,12 @@
+import { PathRecord, Location, Blocker } from '../types';
+import BaseHistory, { PushOptions } from './base';
+export default class BrowserHistory extends BaseHistory {
+    private _history;
+    constructor();
+    push(to: PathRecord, { state, redirectedFrom }?: PushOptions): void;
+    replace(to: PathRecord, { state, redirectedFrom }?: PushOptions): void;
+    go(delta: number): void;
+    block(blocker: Blocker): () => void;
+    setup(): void;
+    protected getIndexAndLocation(): [number, Location];
+}

package/esm/history/browser.js

@@ -0,0 +1,104 @@
+import { createLocation, pushState, replaceState, addBlocker, warning } from '../utils';
+import BaseHistory, { ACTION_POP, ACTION_REPLACE } from './base';
+export default class BrowserHistory extends BaseHistory {
+    constructor() {
+        super();
+        this._history = window.history;
+        [this._index, this.location] = this.getIndexAndLocation();
+        if (this._index == null) {
+            this._index = 0;
+            this._history.replaceState(Object.assign(Object.assign({}, this._history.state), { idx: this._index }), '');
+        }
+    }
+    push(to, { state, redirectedFrom } = {}) {
+        return this.transitionTo(to, {
+            state,
+            redirectedFrom,
+            onTransition({ state, url }) {
+                pushState(state, url);
+            }
+        });
+    }
+    replace(to, { state, redirectedFrom } = {}) {
+        return this.transitionTo(to, {
+            state,
+            action: ACTION_REPLACE,
+            redirectedFrom,
+            onTransition({ state, url }) {
+                replaceState(state, url);
+            }
+        });
+    }
+    go(delta) {
+        this._history.go(delta);
+    }
+    block(blocker) {
+        return addBlocker(this._blockers, blocker);
+    }
+    setup() {
+        let blockedPopTx = null;
+        const handlePop = () => {
+            const index = this._index;
+            const blockers = this._blockers;
+            if (blockedPopTx) {
+                blockers.call(blockedPopTx);
+                blockedPopTx = null;
+            }
+            else {
+                let nextAction = ACTION_POP;
+                let [nextIndex, nextLocation] = this.getIndexAndLocation();
+                if (blockers.length) {
+                    if (nextIndex != null) {
+                        let delta = index - nextIndex;
+                        if (delta) {
+                            // Revert the POP
+                            blockedPopTx = {
+                                action: nextAction,
+                                location: nextLocation,
+                                retry: () => {
+                                    this.go(delta * -1);
+                                }
+                            };
+                            this.go(delta);
+                        }
+                    }
+                    else {
+                        // Trying to POP to a location with no index. We did not create
+                        // this location, so we can't effectively block the navigation.
+                        warning(false, 
+                        // TODO: Write up a doc that explains our blocking strategy in
+                        // detail and link to it here so people can understand better what
+                        // is going on and how to avoid it.
+                        `You are trying to block a POP navigation to a location that was not ` +
+                            `created by the history library. The block will fail silently in ` +
+                            `production, but in general you should do all navigation with the ` +
+                            `history library (instead of using window.history.pushState directly) ` +
+                            `to avoid this situation.`);
+                    }
+                }
+                else {
+                    this.transitionTo(nextLocation, {
+                        onTransition: () => { },
+                        action: nextAction
+                    });
+                }
+            }
+        };
+        window.addEventListener('popstate', handlePop);
+    }
+    getIndexAndLocation() {
+        const { pathname, search, hash } = window.location;
+        const state = this._history.state || {};
+        return [
+            state.idx,
+            createLocation({
+                pathname,
+                search,
+                hash
+            }, {
+                state: state.usr || null,
+                key: state.key || 'default'
+            })
+        ];
+    }
+}

package/esm/history/hash.d.ts

@@ -0,0 +1,13 @@
+import { PathRecord, Location, Blocker, ResolvedPath } from '../types';
+import BaseHistory, { PushOptions } from './base';
+export default class HashHistory extends BaseHistory {
+    private _history;
+    constructor();
+    push(to: PathRecord, { state, redirectedFrom }?: PushOptions): void;
+    replace(to: PathRecord, { state, redirectedFrom }?: PushOptions): void;
+    go(delta: number): void;
+    block(blocker: Blocker): () => void;
+    resolve(to: any, from?: any): ResolvedPath;
+    setup(): void;
+    protected getIndexAndLocation(): [number, Location];
+}

package/esm/history/hash.js

@@ -0,0 +1,135 @@
+import { createLocation, pushState, replaceState, addBlocker, resolvePath, pathToString, warning } from '../utils';
+import BaseHistory, { ACTION_POP, ACTION_REPLACE } from './base';
+function getBaseHref() {
+    let base = document.querySelector('base');
+    let href = '';
+    if (base && base.getAttribute('href')) {
+        let url = window.location.href;
+        let hashIndex = url.indexOf('#');
+        href = hashIndex === -1 ? url : url.slice(0, hashIndex);
+    }
+    return href;
+}
+function createHref(to) {
+    return (getBaseHref() +
+        '#' +
+        (typeof to === 'string' ? to : pathToString(resolvePath(to))));
+}
+export default class HashHistory extends BaseHistory {
+    constructor() {
+        super();
+        this._history = window.history;
+        [this._index, this.location] = this.getIndexAndLocation();
+        if (this._index == null) {
+            this._index = 0;
+            this._history.replaceState(Object.assign(Object.assign({}, this._history.state), { idx: this._index }), '');
+        }
+    }
+    push(to, { state, redirectedFrom } = {}) {
+        return this.transitionTo(to, {
+            state,
+            redirectedFrom,
+            onTransition({ state, url }) {
+                pushState(state, url);
+            }
+        });
+    }
+    replace(to, { state, redirectedFrom } = {}) {
+        return this.transitionTo(to, {
+            state,
+            action: ACTION_REPLACE,
+            redirectedFrom,
+            onTransition({ state, url }) {
+                replaceState(state, url);
+            }
+        });
+    }
+    go(delta) {
+        this._history.go(delta);
+    }
+    block(blocker) {
+        return addBlocker(this._blockers, blocker);
+    }
+    resolve(to, from) {
+        const toPath = resolvePath(to, from);
+        return {
+            path: toPath,
+            href: createHref(toPath)
+        };
+    }
+    setup() {
+        let blockedPopTx = null;
+        const handlePop = () => {
+            const index = this._index;
+            const blockers = this._blockers;
+            if (blockedPopTx) {
+                blockers.call(blockedPopTx);
+                blockedPopTx = null;
+            }
+            else {
+                let nextAction = ACTION_POP;
+                let [nextIndex, nextLocation] = this.getIndexAndLocation();
+                if (blockers.length) {
+                    if (nextIndex != null) {
+                        let delta = index - nextIndex;
+                        if (delta) {
+                            // Revert the POP
+                            blockedPopTx = {
+                                action: nextAction,
+                                location: nextLocation,
+                                retry: () => {
+                                    this.go(delta * -1);
+                                }
+                            };
+                            this.go(delta);
+                        }
+                    }
+                    else {
+                        // Trying to POP to a location with no index. We did not create
+                        // this location, so we can't effectively block the navigation.
+                        warning(false, 
+                        // TODO: Write up a doc that explains our blocking strategy in
+                        // detail and link to it here so people can understand better what
+                        // is going on and how to avoid it.
+                        `You are trying to block a POP navigation to a location that was not ` +
+                            `created by the history library. The block will fail silently in ` +
+                            `production, but in general you should do all navigation with the ` +
+                            `history library (instead of using window.history.pushState directly) ` +
+                            `to avoid this situation.`);
+                    }
+                }
+                else {
+                    this.transitionTo(nextLocation, {
+                        onTransition: () => { },
+                        action: nextAction
+                    });
+                }
+            }
+        };
+        window.addEventListener('popstate', handlePop);
+        // popstate does not fire on hashchange in IE 11 and old (trident) Edge
+        // https://developer.mozilla.org/de/docs/Web/API/Window/popstate_event
+        window.addEventListener('hashchange', () => {
+            const [, nextLocation] = this.getIndexAndLocation();
+            // Ignore extraneous hashchange events.
+            if (pathToString(nextLocation) !== pathToString(this.location)) {
+                handlePop();
+            }
+        });
+    }
+    getIndexAndLocation() {
+        const { pathname, search, hash } = resolvePath(window.location.hash.substr(1));
+        const state = this._history.state || {};
+        return [
+            state.idx,
+            createLocation({
+                pathname,
+                search,
+                hash
+            }, {
+                state: state.usr || null,
+                key: state.key || 'default'
+            })
+        ];
+    }
+}

package/esm/history/index.d.ts

@@ -0,0 +1,7 @@
+import MemoryHistory, { MemoryHistoryOptions, InitialEntry } from './memory';
+import BrowserHistory from './browser';
+import HashHistory from './hash';
+export { MemoryHistory, MemoryHistoryOptions, InitialEntry };
+export declare function createBrowserHistory(): BrowserHistory;
+export declare function createHashHistory(): HashHistory;
+export declare function createMemoryHistory(options?: MemoryHistoryOptions): MemoryHistory;

package/esm/history/index.js

@@ -0,0 +1,13 @@
+import MemoryHistory from './memory';
+import BrowserHistory from './browser';
+import HashHistory from './hash';
+export { MemoryHistory };
+export function createBrowserHistory() {
+    return new BrowserHistory();
+}
+export function createHashHistory() {
+    return new HashHistory();
+}
+export function createMemoryHistory(options = {}) {
+    return new MemoryHistory(options);
+}

package/esm/history/memory.d.ts

@@ -0,0 +1,22 @@
+import { PathRecord, Location, Blocker, PartialLocation, ResolvedPath } from '../types';
+import BaseHistory, { PushOptions } from './base';
+/**
+ * A user-supplied object that describes a location. Used when providing
+ * entries to `createMemoryHistory` via its `initialEntries` option.
+ */
+export declare type InitialEntry = string | PartialLocation;
+export declare type MemoryHistoryOptions = {
+    initialEntries?: InitialEntry[];
+    initialIndex?: number;
+};
+export default class MemoryHistory extends BaseHistory {
+    private _entries;
+    constructor({ initialEntries, initialIndex }?: MemoryHistoryOptions);
+    setup(): void;
+    push(to: PathRecord, { state, redirectedFrom }?: PushOptions): void;
+    replace(to: PathRecord, { state, redirectedFrom }?: PushOptions): void;
+    go(delta: number): void;
+    block(blocker: Blocker): () => void;
+    resolve(to: PathRecord, from?: string): ResolvedPath;
+    protected getIndexAndLocation(): [number, Location];
+}

package/esm/history/memory.js

@@ -0,0 +1,75 @@
+import { createLocation, resolvePath, pathToString, warning } from '../utils';
+import BaseHistory, { ACTION_POP, ACTION_REPLACE } from './base';
+function clamp(n, lowerBound, upperBound) {
+    return Math.min(Math.max(n, lowerBound), upperBound);
+}
+export default class MemoryHistory extends BaseHistory {
+    constructor({ initialEntries = ['/'], initialIndex } = {}) {
+        super();
+        this._entries = [];
+        this._entries = initialEntries.map(entry => {
+            let location = createLocation(Object.assign({ pathname: '/', search: '', hash: '' }, (typeof entry === 'string' ? resolvePath(entry) : entry)));
+            warning(location.pathname.charAt(0) === '/', `Relative pathnames are not supported in createMemoryHistory({ initialEntries }) (invalid entry: ${JSON.stringify(entry)})`);
+            return location;
+        });
+        this._index = clamp(initialIndex == null ? this._entries.length - 1 : initialIndex, 0, this._entries.length - 1);
+        this.location = this._entries[this._index];
+    }
+    setup() {
+        // do nothing
+    }
+    push(to, { state, redirectedFrom } = {}) {
+        return this.transitionTo(to, {
+            state,
+            redirectedFrom,
+            onTransition: ({ location }) => {
+                this._index += 1;
+                this._entries.splice(this._index, this._entries.length, location);
+            }
+        });
+    }
+    replace(to, { state, redirectedFrom } = {}) {
+        return this.transitionTo(to, {
+            state,
+            action: ACTION_REPLACE,
+            redirectedFrom,
+            onTransition: ({ location }) => {
+                this._entries[this._index] = location;
+            }
+        });
+    }
+    go(delta) {
+        const { _index: index, _entries: entries } = this;
+        let nextIndex = clamp(index + delta, 0, entries.length - 1);
+        let nextAction = ACTION_POP;
+        let nextLocation = entries[nextIndex];
+        // check transition
+        if (this._blockers.length) {
+            this._blockers.call({
+                action: nextAction,
+                location: nextLocation,
+                retry: () => {
+                    this.go(delta);
+                }
+            });
+            return;
+        }
+        this.transitionTo(nextLocation.pathname, Object.assign(Object.assign({}, nextLocation), { action: nextAction, onTransition: ({ location }) => {
+                this._index = nextIndex;
+            } }));
+    }
+    block(blocker) {
+        return this._blockers.push(blocker);
+    }
+    resolve(to, from) {
+        const toPath = resolvePath(to, from);
+        return {
+            path: toPath,
+            href: pathToString(toPath)
+        };
+    }
+    getIndexAndLocation() {
+        const index = this._index;
+        return [index, this._entries[index]];
+    }
+}

package/esm/index.d.ts

@@ -0,0 +1,7 @@
+export { createRoutesFromArray } from './createRoutesFromArray';
+export { matchPathname, matchStringify } from './matchPathname';
+export { matchRoutes, IRouteBaseObject, rankRouteBranches } from './matchRoutes';
+export { pathToString, parseQuery, resolvePath, createLocation, createRedirector } from './utils';
+export * from './types';
+export * from './history';
+export * from './router';

package/esm/index.js

@@ -0,0 +1,7 @@
+export { createRoutesFromArray } from './createRoutesFromArray';
+export { matchPathname, matchStringify } from './matchPathname';
+export { matchRoutes, rankRouteBranches } from './matchRoutes';
+export { pathToString, parseQuery, resolvePath, createLocation, createRedirector } from './utils';
+export * from './types';
+export * from './history';
+export * from './router';

package/esm/matchPathname.d.ts

@@ -0,0 +1,15 @@
+import { IPathPattern, IPathMatch, IParams } from './types';
+import { PathParserOptions } from './pathParserRanker';
+/**
+ * match pathname, online link https://paths.esm.dev/?p=AAMeJSyAwR4UbFDAFxAcAGAIJnMCo0SmCHGYBdyBsATSBUQBsAPABAwxsAHeGVJwuLlARA..#
+ * @param pattern
+ * @param pathname
+ */
+export declare function matchPathname(pattern: IPathPattern, pathname: string): IPathMatch | null;
+/**
+ * stringify path to string by params and options
+ * @param path
+ * @param params
+ * @param options
+ */
+export declare function matchStringify(path: string, params: IParams, options?: PathParserOptions): string;

package/esm/matchPathname.js

@@ -0,0 +1,54 @@
+import { tokensToParser } from './pathParserRanker';
+import { tokenizePath } from './pathTokenizer';
+function safelyDecodeURIComponent(value, paramName, optional) {
+    try {
+        if (Array.isArray(value)) {
+            return value.map((item) => {
+                return decodeURIComponent(item.replace(/\+/g, ' '));
+            });
+        }
+        return decodeURIComponent(value.replace(/\+/g, ' '));
+    }
+    catch (error) {
+        if (!optional) {
+            console.warn(`The value for the URL param "${paramName}" will not be decoded because` +
+                ` the string "${value}" is a malformed URL segment. This is probably` +
+                ` due to a bad percent encoding (${error}).`);
+        }
+        return value;
+    }
+}
+/**
+ * match pathname, online link https://paths.esm.dev/?p=AAMeJSyAwR4UbFDAFxAcAGAIJnMCo0SmCHGYBdyBsATSBUQBsAPABAwxsAHeGVJwuLlARA..#
+ * @param pattern
+ * @param pathname
+ */
+export function matchPathname(pattern, pathname) {
+    if (typeof pattern === 'string') {
+        pattern = { path: pattern };
+    }
+    const { path, caseSensitive = false, end = true } = pattern;
+    const pathParser = tokensToParser(tokenizePath(path), { end, sensitive: caseSensitive });
+    ;
+    const matchResult = pathParser.parse(pathname);
+    if (!matchResult)
+        return null;
+    const { keys = [] } = pathParser;
+    const { match, params } = matchResult;
+    const safelyDecodetParams = (keys).reduce((memo, key, index) => {
+        const keyName = key.name;
+        memo[keyName] = safelyDecodeURIComponent(params[keyName], String(keyName), key.optional);
+        return memo;
+    }, {});
+    return { path, pathname: match, params: safelyDecodetParams };
+}
+/**
+ * stringify path to string by params and options
+ * @param path
+ * @param params
+ * @param options
+ */
+export function matchStringify(path, params, options) {
+    const pathParser = tokensToParser(tokenizePath(path), options);
+    return pathParser.stringify(params);
+}

package/esm/matchRoutes.d.ts

@@ -0,0 +1,6 @@
+import { IRouteRecord, IRouteMatch, PartialLocation } from './types';
+export interface IRouteBaseObject<Element = any> extends Omit<IRouteRecord<Element>, 'children' | 'element' | 'filepath'> {
+    children?: IRouteBaseObject<Element>[];
+}
+export declare function rankRouteBranches<T extends [string, ...any[]]>(branches: T[]): T[];
+export declare function matchRoutes<T extends IRouteBaseObject>(routes: T[], location: string | PartialLocation, basename?: string): IRouteMatch<T>[] | null;