waymark 0.1.1 → 0.2.0

package/dist/router/browser-history.js

@@ -1,48 +0,0 @@
-import { getHref, normalizeSearch } from "../utils";
-export class BrowserHistory {
-    static patchKey = Symbol.for("waymark_history_patch_v01");
-    constructor() {
-        if (typeof history !== "undefined" &&
-            !Object.hasOwn(window, BrowserHistory.patchKey)) {
-            for (const type of [pushStateEvent, replaceStateEvent]) {
-                const original = history[type];
-                history[type] = function (...args) {
-                    const result = original.apply(this, args);
-                    const event = new Event(type);
-                    event.arguments = args;
-                    dispatchEvent(event);
-                    return result;
-                };
-            }
-            Object.assign(window, {
-                [BrowserHistory.patchKey]: true
-            });
-        }
-    }
-    getPath = () => location.pathname;
-    getSearch = () => normalizeSearch(location.search);
-    getState = () => history.state;
-    go = (delta) => history.go(delta);
-    push = (options) => {
-        const { path, search, replace, state } = options;
-        const href = getHref(path, search);
-        history[replace ? replaceStateEvent : pushStateEvent](state, "", href);
-    };
-    subscribe = (listener) => {
-        events.forEach(event => window.addEventListener(event, listener));
-        return () => {
-            events.forEach(event => window.removeEventListener(event, listener));
-        };
-    };
-}
-// Events
-const popStateEvent = "popstate";
-const pushStateEvent = "pushState";
-const replaceStateEvent = "replaceState";
-const hashChangeEvent = "hashchange";
-const events = [
-    popStateEvent,
-    pushStateEvent,
-    replaceStateEvent,
-    hashChangeEvent
-];

package/dist/router/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./router";
-export * from "./browser-history";
-export * from "./memory-history";

package/dist/router/index.js

@@ -1,3 +0,0 @@
-export * from "./router";
-export * from "./browser-history";
-export * from "./memory-history";

package/dist/router/memory-history.d.ts

@@ -1,18 +0,0 @@
-import { type HistoryLike, type HistoryPushOptions } from "../utils";
-export interface MemoryLocation {
-    path: string;
-    search: string;
-    state: any;
-}
-export declare class MemoryHistory implements HistoryLike {
-    private stack;
-    private index;
-    private listeners;
-    constructor(initial?: Partial<MemoryLocation>);
-    getPath: () => string;
-    getSearch: () => string;
-    getState: () => any;
-    go: (delta: number) => void;
-    push: (options: HistoryPushOptions) => void;
-    subscribe: (listener: () => void) => () => void;
-}

package/dist/router/memory-history.js

@@ -1,39 +0,0 @@
-import { clamp, normalizeSearch } from "../utils";
-export class MemoryHistory {
-    stack = [];
-    index = 0;
-    listeners = new Set();
-    constructor(initial = {}) {
-        const { path = "/", search = "", state } = initial;
-        this.stack.push({ path, search: normalizeSearch(search), state });
-    }
-    getPath = () => this.stack[this.index].path;
-    getSearch = () => this.stack[this.index].search;
-    getState = () => this.stack[this.index].state;
-    go = (delta) => {
-        this.index = clamp(this.index + delta, 0, this.stack.length - 1);
-        this.listeners.forEach(listener => listener());
-    };
-    push = (options) => {
-        const { path, search = "", replace, state } = options;
-        const location = {
-            path,
-            search: normalizeSearch(search),
-            state
-        };
-        this.stack = this.stack.slice(0, this.index + 1);
-        if (replace) {
-            this.stack[this.index] = location;
-        }
-        else {
-            this.index = this.stack.push(location) - 1;
-        }
-        this.listeners.forEach(listener => listener());
-    };
-    subscribe = (listener) => {
-        this.listeners.add(listener);
-        return () => {
-            this.listeners.delete(listener);
-        };
-    };
-}

package/dist/router/router.d.ts

@@ -1,31 +0,0 @@
-import type { LinkOptions } from "../react";
-import { type Routes, type PatternRoute, type RouteList, type Patterns, type NavigateOptions, type HistoryLike, type RouteParams, type RouteSearch } from "../utils";
-export interface RouterOptions {
-    history?: HistoryLike;
-    basePath?: string;
-    routes: RouteList;
-    defaultLinkOptions?: LinkOptions;
-}
-export declare class Router {
-    history: HistoryLike;
-    basePath: string;
-    routes: RouteList;
-    defaultLinkOptions?: LinkOptions;
-    _: {
-        routeMap: Map<string, Routes>;
-    };
-    constructor(options: RouterOptions);
-    getPath(cpath: string): string;
-    getCanonicalPath(path: string): string;
-    matchPath(path: string): Routes | undefined;
-    getRoute<P extends Patterns>(pattern: P): PatternRoute<P>;
-    composePath<P extends Patterns>(options: NavigateOptions<P>): {
-        path: string;
-        search: string;
-    };
-    decomposePath<R extends Routes>(route: R, path: string, search: string): {
-        params: RouteParams<R>;
-        search: RouteSearch<R>;
-    };
-    navigate<P extends Patterns>(options: NavigateOptions<P> | number): void;
-}

package/dist/router/router.js

@@ -1,64 +0,0 @@
-import { inject } from "regexparam";
-import { BrowserHistory } from "./browser-history";
-import { normalizePath, extract, stringifySearch, parseSearch } from "../utils";
-export class Router {
-    history;
-    basePath;
-    routes;
-    defaultLinkOptions;
-    _;
-    constructor(options) {
-        this.history = options.history ?? new BrowserHistory();
-        this.basePath = normalizePath(options.basePath ?? "/");
-        this.routes = options.routes;
-        this.defaultLinkOptions = options.defaultLinkOptions;
-        this._ = {
-            routeMap: new Map(options.routes.map(route => [route._.pattern, route]))
-        };
-    }
-    getPath(cpath) {
-        return normalizePath(`${this.basePath}/${cpath}`);
-    }
-    getCanonicalPath(path) {
-        if (path === this.basePath || path.startsWith(`${this.basePath}/`)) {
-            path = path.slice(this.basePath.length) || "/";
-        }
-        return path;
-    }
-    matchPath(path) {
-        const cpath = this.getCanonicalPath(path);
-        return this.routes.find(route => route._.regex.test(cpath));
-    }
-    getRoute(pattern) {
-        const route = this._.routeMap.get(pattern);
-        if (!route) {
-            throw new Error(`[Waymark] Route not found for pattern: ${pattern}`);
-        }
-        return route;
-    }
-    composePath(options) {
-        const { to, params, search } = options;
-        return {
-            path: this.getPath(params ? inject(to, params) : to),
-            search: search ? stringifySearch(search) : ""
-        };
-    }
-    decomposePath(route, path, search) {
-        const { keys, looseRegex, mapSearch } = route._;
-        const cpath = this.getCanonicalPath(path);
-        return {
-            params: extract(cpath, looseRegex, keys),
-            search: mapSearch(parseSearch(search))
-        };
-    }
-    navigate(options) {
-        if (typeof options === "number") {
-            this.history.go(options);
-        }
-        else {
-            const { path, search } = this.composePath(options);
-            const { replace, state } = options;
-            this.history.push({ path, search, replace, state });
-        }
-    }
-}

package/dist/utils/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./path";
-export * from "./router";
-export * from "./search";
-export * from "./react";
-export * from "./misc";

package/dist/utils/index.js

@@ -1,5 +0,0 @@
-export * from "./path";
-export * from "./router";
-export * from "./search";
-export * from "./react";
-export * from "./misc";

package/dist/utils/misc.d.ts

@@ -1,17 +0,0 @@
-import type { Simplify, EmptyObject } from "type-fest";
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-export type MaybeKey<K extends string, T> = T extends EmptyObject ? {
-    [P in K]?: undefined;
-} : {} extends T ? {
-    [P in K]?: T;
-} : {
-    [P in K]: T;
-};
-export type OptionalOnUndefined<T extends object> = Simplify<{
-    [K in keyof T as undefined extends T[K] ? never : K]: T[K];
-} & {
-    [K in keyof T as undefined extends T[K] ? K : never]?: T[K];
-}>;
-export declare function getHref(path: string, search?: string): string;
-export declare function clamp(value: number, min: number, max: number): number;
-export declare function validator<Input, Output>(validate: ((input: Input) => Output) | StandardSchemaV1<Input, Output>): (input: Input) => Output;

package/dist/utils/misc.js

@@ -1,27 +0,0 @@
-export function getHref(path, search) {
-    return `${path}${search ? `?${search}` : ""}`;
-}
-export function clamp(value, min, max) {
-    return Math.max(min, Math.min(value, max));
-}
-export function validator(validate) {
-    if (typeof validate === "function") {
-        return validate;
-    }
-    else {
-        return (input) => {
-            const result = validate["~standard"].validate(input);
-            if (result instanceof Promise) {
-                throw new Error("[Waymark] Validation must be synchronous");
-            }
-            else if (result.issues) {
-                throw new Error("[Waymark] Validation failed", {
-                    cause: result.issues
-                });
-            }
-            else {
-                return result.value;
-            }
-        };
-    }
-}

package/dist/utils/path.d.ts

@@ -1,9 +0,0 @@
-import type { RouteParams } from "regexparam";
-import type { Simplify } from "type-fest";
-export type ParsePattern<P extends string> = Simplify<RouteParams<P>>;
-export type NormalizePath<P extends string> = RemoveTrailingSlash<DedupSlashes<`/${P}`>>;
-type DedupSlashes<P extends string> = P extends `${infer Prefix}//${infer Rest}` ? `${Prefix}${DedupSlashes<`/${Rest}`>}` : P;
-type RemoveTrailingSlash<P extends string> = P extends `${infer Prefix}/` ? Prefix extends "" ? "/" : Prefix : P;
-export declare function normalizePath<P extends string>(path: P): NormalizePath<P>;
-export declare function extract(cpath: string, looseRegex: RegExp, keys: string[]): Record<string, string>;
-export {};

package/dist/utils/path.js

@@ -1,19 +0,0 @@
-export function normalizePath(path) {
-    const normalized = `/${path}`
-        .replaceAll(/\/+/g, "/")
-        .replace(/(.+)\/$/, "$1");
-    return normalized;
-}
-export function extract(cpath, looseRegex, keys) {
-    const out = {};
-    const matches = looseRegex.exec(cpath);
-    if (matches) {
-        keys.forEach((key, i) => {
-            const match = matches[i + 1];
-            if (match) {
-                out[key] = match;
-            }
-        });
-    }
-    return out;
-}

package/dist/utils/react.d.ts

@@ -1,10 +0,0 @@
-import { type Ref, type ComponentType } from "react";
-export type Updater<T extends object> = Partial<T> | ((prev: T) => Partial<T>);
-export type ComponentLoader = () => Promise<ComponentType | {
-    default: ComponentType;
-}>;
-export declare function defaultLinkActive(currentPath: string, targetPath: string): boolean;
-export declare function mergeRefs<T>(...inputRefs: (Ref<T> | undefined)[]): Ref<T>;
-export declare function errorBoundary(component: ComponentType<{
-    error: unknown;
-}>): ComponentType;

package/dist/utils/react.js

@@ -1,50 +0,0 @@
-import { createElement, Component } from "react";
-import { useOutlet } from "../react";
-export function defaultLinkActive(currentPath, targetPath) {
-    return currentPath.startsWith(targetPath);
-}
-export function mergeRefs(...inputRefs) {
-    const filtered = inputRefs.filter(r => !!r);
-    if (filtered.length <= 1) {
-        return filtered[0] ?? null;
-    }
-    return value => {
-        const cleanups = [];
-        for (const ref of filtered) {
-            const cleanup = assignRef(ref, value);
-            cleanups.push(cleanup ?? (() => assignRef(ref, null)));
-        }
-        return () => cleanups.forEach(cleanup => cleanup());
-    };
-}
-function assignRef(ref, value) {
-    if (typeof ref === "function") {
-        return ref(value);
-    }
-    else if (ref) {
-        ref.current = value;
-    }
-}
-export function errorBoundary(component) {
-    class Catch extends Component {
-        constructor(props) {
-            super(props);
-            this.state = { children: props.children, error: null };
-        }
-        static getDerivedStateFromError(error) {
-            return { error: [error] };
-        }
-        static getDerivedStateFromProps(props, state) {
-            if (props.children !== state.children) {
-                return { children: props.children, error: null };
-            }
-            return state;
-        }
-        render() {
-            return this.state.error
-                ? createElement(component, { error: this.state.error[0] })
-                : this.props.children;
-        }
-    }
-    return () => createElement(Catch, { children: useOutlet() });
-}

package/dist/utils/router.d.ts

@@ -1,37 +0,0 @@
-import type { Route } from "../route";
-import type { MaybeKey } from "./misc";
-export interface RegisterRoutes {
-}
-export type RouteList = RegisterRoutes extends {
-    routes: infer RouteList extends ReadonlyArray<Route<string, any, any>>;
-} ? RouteList : ReadonlyArray<Route<string, any, any>>;
-export type Routes = RouteList[number];
-export type Patterns = Routes["_"]["pattern"];
-export type RouteParams<R extends Routes> = NonNullable<R["_"]["_params"]>;
-export type RouteSearch<R extends Routes> = NonNullable<R["_"]["_search"]>;
-export type PatternParams<P extends Patterns> = RouteParams<PatternRoute<P>>;
-export type PatternSearch<P extends Patterns> = RouteSearch<PatternRoute<P>>;
-export type PatternRoute<P extends Patterns> = Extract<Routes, {
-    _: {
-        pattern: P;
-    };
-}>;
-export type NavigateOptions<P extends Patterns> = {
-    to: P;
-    replace?: boolean;
-    state?: any;
-} & MaybeKey<"params", PatternParams<P>> & MaybeKey<"search", PatternSearch<P>>;
-export interface HistoryPushOptions {
-    path: string;
-    search?: string;
-    replace?: boolean;
-    state?: any;
-}
-export interface HistoryLike {
-    getPath: () => string;
-    getSearch: () => string;
-    getState: () => any;
-    go: (delta: number) => void;
-    push: (options: HistoryPushOptions) => void;
-    subscribe: (listener: () => void) => () => void;
-}

package/dist/utils/router.js

@@ -1 +0,0 @@
-export {};

package/dist/utils/search.d.ts

@@ -1,3 +0,0 @@
-export declare function normalizeSearch(search: string): string;
-export declare function stringifySearch(search: Record<string, unknown>): string;
-export declare function parseSearch(search: string): Record<string, unknown>;

package/dist/utils/search.js

@@ -1,31 +0,0 @@
-export function normalizeSearch(search) {
-    return search.startsWith("?") ? search.slice(1) : search;
-}
-export function stringifySearch(search) {
-    return Object.entries(search)
-        .filter(([_, value]) => value !== undefined)
-        .map(([key, value]) => `${key}=${encodeURIComponent(toValueString(value))}`)
-        .join("&");
-}
-export function parseSearch(search) {
-    const urlSearch = new URLSearchParams(search);
-    return Object.fromEntries([...urlSearch.entries()].map(([key, value]) => {
-        value = decodeURIComponent(value);
-        return [key, isJSONString(value) ? JSON.parse(value) : value];
-    }));
-}
-function toValueString(value) {
-    if (typeof value === "string" && !isJSONString(value)) {
-        return value;
-    }
-    return JSON.stringify(value);
-}
-function isJSONString(value) {
-    try {
-        JSON.parse(value);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}