toiljs 0.0.15 → 0.0.19

package/build/client/channel.js

@@ -1,94 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from 'react';
-export function resolveChannelUrl(path = '/_toil', location = window.location) {
-    const scheme = location.protocol === 'https:' ? 'wss:' : 'ws:';
-    const normalized = path.startsWith('/') ? path : `/${path}`;
-    return `${scheme}//${location.host}${normalized}`;
-}
-export function connectChannel(onMessage, options = {}) {
-    const url = options.url ?? resolveChannelUrl(options.path);
-    const reconnect = options.reconnect ?? true;
-    const delay = options.reconnectDelay ?? 1000;
-    let socket = null;
-    let stopped = false;
-    let timer;
-    const open = () => {
-        const ws = new WebSocket(url);
-        ws.binaryType = 'arraybuffer';
-        socket = ws;
-        ws.addEventListener('message', (event) => {
-            if (typeof event.data === 'string')
-                onMessage(event.data);
-            else if (event.data instanceof ArrayBuffer)
-                onMessage(event.data);
-        });
-        ws.addEventListener('close', () => {
-            if (!stopped && reconnect)
-                timer = setTimeout(open, delay);
-        });
-    };
-    open();
-    return {
-        send: (data) => {
-            if (socket && socket.readyState === WebSocket.OPEN)
-                socket.send(data);
-        },
-        close: () => {
-            stopped = true;
-            if (timer !== undefined)
-                clearTimeout(timer);
-            socket?.close();
-        },
-    };
-}
-export function useChannel(options = {}) {
-    const { path, url, reconnect, reconnectDelay } = options;
-    const [connected, setConnected] = useState(false);
-    const [messages, setMessages] = useState([]);
-    const socketRef = useRef(null);
-    useEffect(() => {
-        const target = url ?? resolveChannelUrl(path);
-        const shouldReconnect = reconnect ?? true;
-        const delay = reconnectDelay ?? 1000;
-        let stopped = false;
-        let timer;
-        const open = () => {
-            const ws = new WebSocket(target);
-            ws.binaryType = 'arraybuffer';
-            socketRef.current = ws;
-            ws.addEventListener('open', () => {
-                if (!stopped)
-                    setConnected(true);
-            });
-            ws.addEventListener('message', (event) => {
-                if (typeof event.data === 'string') {
-                    const data = event.data;
-                    setMessages((prev) => [...prev, data]);
-                }
-                else if (event.data instanceof ArrayBuffer) {
-                    const data = event.data;
-                    setMessages((prev) => [...prev, data]);
-                }
-            });
-            ws.addEventListener('close', () => {
-                if (stopped)
-                    return;
-                setConnected(false);
-                if (shouldReconnect)
-                    timer = setTimeout(open, delay);
-            });
-        };
-        open();
-        return () => {
-            stopped = true;
-            if (timer !== undefined)
-                clearTimeout(timer);
-            socketRef.current?.close();
-        };
-    }, [path, url, reconnect, reconnectDelay]);
-    const send = useCallback((data) => {
-        const socket = socketRef.current;
-        if (socket && socket.readyState === WebSocket.OPEN)
-            socket.send(data);
-    }, []);
-    return { connected, messages, send };
-}

package/build/client/error-boundary.d.ts

@@ -1,16 +0,0 @@
-import { Component, type ComponentType, type ReactNode } from 'react';
-import type { RouteErrorProps } from './types.js';
-interface ErrorBoundaryProps {
-    readonly fallback: ComponentType<RouteErrorProps>;
-    readonly children: ReactNode;
-}
-interface ErrorBoundaryState {
-    readonly error: Error | null;
-}
-export declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
-    state: ErrorBoundaryState;
-    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
-    reset: () => void;
-    render(): ReactNode;
-}
-export {};

package/build/client/error-boundary.js

@@ -1,19 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { Component, Suspense } from 'react';
-export class ErrorBoundary extends Component {
-    state = { error: null };
-    static getDerivedStateFromError(error) {
-        return { error };
-    }
-    reset = () => {
-        this.setState({ error: null });
-    };
-    render() {
-        const { error } = this.state;
-        if (error) {
-            const Fallback = this.props.fallback;
-            return (_jsx(Suspense, { fallback: null, children: _jsx(Fallback, { error: error, reset: this.reset }) }));
-        }
-        return this.props.children;
-    }
-}

package/build/client/head.d.ts

@@ -1,26 +0,0 @@
-export interface MetaTag {
-    readonly name?: string;
-    readonly property?: string;
-    readonly content: string;
-    readonly [attr: string]: string | undefined;
-}
-export interface LinkTag {
-    readonly rel: string;
-    readonly href: string;
-    readonly [attr: string]: string | undefined;
-}
-export interface HeadSpec {
-    readonly title?: string;
-    readonly titleTemplate?: string;
-    readonly meta?: readonly MetaTag[];
-    readonly link?: readonly LinkTag[];
-}
-export interface ResolvedHead {
-    readonly title?: string;
-    readonly meta: MetaTag[];
-    readonly link: LinkTag[];
-}
-export declare function mergeHead(specs: readonly HeadSpec[]): ResolvedHead;
-export declare function useHead(spec: HeadSpec): void;
-export declare function useTitle(title: string): void;
-export declare function Head(props: HeadSpec): null;

package/build/client/head.js

@@ -1,87 +0,0 @@
-import { useEffect } from 'react';
-function metaKey(m) {
-    if (m.name !== undefined)
-        return `name:${m.name}`;
-    if (m.property !== undefined)
-        return `property:${m.property}`;
-    return `meta:${JSON.stringify(m)}`;
-}
-export function mergeHead(specs) {
-    let title;
-    let titleTemplate;
-    const meta = new Map();
-    const link = new Map();
-    for (const spec of specs) {
-        if (spec.title !== undefined)
-            title = spec.title;
-        if (spec.titleTemplate !== undefined)
-            titleTemplate = spec.titleTemplate;
-        for (const m of spec.meta ?? [])
-            meta.set(metaKey(m), m);
-        for (const l of spec.link ?? [])
-            link.set(`${l.rel}:${l.href}`, l);
-    }
-    const resolvedTitle = title !== undefined && titleTemplate !== undefined
-        ? titleTemplate.replace('%s', title)
-        : title;
-    return { title: resolvedTitle, meta: [...meta.values()], link: [...link.values()] };
-}
-const entries = new Map();
-let order = [];
-let seq = 0;
-let baseTitle = null;
-function setAttrs(el, attrs) {
-    el.setAttribute('data-toil-head', '');
-    for (const [key, value] of Object.entries(attrs)) {
-        if (value !== undefined)
-            el.setAttribute(key, value);
-    }
-}
-function apply() {
-    if (typeof document === 'undefined')
-        return;
-    if (baseTitle === null)
-        baseTitle = document.title;
-    const resolved = mergeHead(order.map((id) => entries.get(id)).filter((s) => !!s));
-    document.title = resolved.title ?? baseTitle;
-    for (const stale of document.head.querySelectorAll('[data-toil-head]'))
-        stale.remove();
-    for (const m of resolved.meta) {
-        const el = document.createElement('meta');
-        setAttrs(el, m);
-        document.head.appendChild(el);
-    }
-    for (const l of resolved.link) {
-        const el = document.createElement('link');
-        setAttrs(el, l);
-        document.head.appendChild(el);
-    }
-}
-function addHead(spec) {
-    const id = ++seq;
-    entries.set(id, spec);
-    order.push(id);
-    apply();
-    return id;
-}
-function removeHead(id) {
-    entries.delete(id);
-    order = order.filter((x) => x !== id);
-    apply();
-}
-export function useHead(spec) {
-    const json = JSON.stringify(spec);
-    useEffect(() => {
-        const id = addHead(JSON.parse(json));
-        return () => {
-            removeHead(id);
-        };
-    }, [json]);
-}
-export function useTitle(title) {
-    useHead({ title });
-}
-export function Head(props) {
-    useHead(props);
-    return null;
-}

package/build/client/hooks.d.ts

@@ -1,17 +0,0 @@
-import type { RouteParams } from './match.js';
-import { navigate, type NavigateOptions } from './navigation.js';
-export interface RouterInstance {
-    push(href: string, options?: NavigateOptions): void;
-    replace(href: string): void;
-    back(): void;
-    forward(): void;
-    refresh(): void;
-    prefetch(href: string): void;
-}
-export declare function useParams(): RouteParams;
-export declare function useNavigate(): typeof navigate;
-export declare function useRouter(): RouterInstance;
-export declare function useLocation(): string;
-export declare function usePathname(): string;
-export declare function useSearchParams(): URLSearchParams;
-export declare function useNavigationPending(): boolean;

package/build/client/hooks.js

@@ -1,48 +0,0 @@
-import { startTransition, useContext, useEffect, useMemo, useReducer, useSyncExternalStore, } from 'react';
-import { back, forward, isNavigationPending, navigate, refresh, subscribeLocation, subscribePending, } from './navigation.js';
-import { ParamsContext } from './params-context.js';
-import { prefetch } from './prefetch.js';
-const ROUTER = {
-    push: (href, options) => {
-        navigate(href, options);
-    },
-    replace: (href) => {
-        navigate(href, { replace: true });
-    },
-    back,
-    forward,
-    refresh,
-    prefetch,
-};
-export function useParams() {
-    return useContext(ParamsContext);
-}
-export function useNavigate() {
-    return navigate;
-}
-export function useRouter() {
-    return ROUTER;
-}
-function useLocationSubscription() {
-    const [, forceUpdate] = useReducer((n) => n + 1, 0);
-    useEffect(() => subscribeLocation(() => {
-        startTransition(() => {
-            forceUpdate();
-        });
-    }), []);
-}
-export function useLocation() {
-    useLocationSubscription();
-    return window.location.pathname;
-}
-export function usePathname() {
-    return useLocation();
-}
-export function useSearchParams() {
-    useLocationSubscription();
-    const search = window.location.search;
-    return useMemo(() => new URLSearchParams(search), [search]);
-}
-export function useNavigationPending() {
-    return useSyncExternalStore(subscribePending, isNavigationPending, () => false);
-}

package/build/client/lazy.d.ts

@@ -1,16 +0,0 @@
-import { type ComponentType, type ReactNode } from 'react';
-import type { LayoutComponentLoader, LayoutLoader, NotFoundLoader, RouteDef, RouteErrorProps } from './types.js';
-type Loader<P> = () => Promise<{
-    default: ComponentType<P>;
-}>;
-export declare function loadingComponent(loader: Loader<object>): ComponentType<object>;
-export declare function errorComponent(loader: Loader<RouteErrorProps>): ComponentType<RouteErrorProps>;
-export declare function pageComponent(route: RouteDef): ComponentType;
-export declare function resolveLayout(loader: NonNullable<LayoutLoader>): ComponentType<{
-    children?: ReactNode;
-}>;
-export declare function nestedLayout(loader: LayoutComponentLoader): ComponentType<{
-    children?: ReactNode;
-}>;
-export declare function resolveNotFound(loader: NonNullable<NotFoundLoader>): ComponentType;
-export {};

package/build/client/lazy.js

@@ -1,53 +0,0 @@
-import { lazy } from 'react';
-function memoLazy(cache, loader) {
-    let component = cache.get(loader);
-    if (!component) {
-        component = lazy(loader);
-        cache.set(loader, component);
-    }
-    return component;
-}
-const loadingCache = new Map();
-export function loadingComponent(loader) {
-    return memoLazy(loadingCache, loader);
-}
-const errorCache = new Map();
-export function errorComponent(loader) {
-    return memoLazy(errorCache, loader);
-}
-const pageCache = new Map();
-export function pageComponent(route) {
-    let component = pageCache.get(route);
-    if (!component) {
-        component = lazy(route.load);
-        pageCache.set(route, component);
-    }
-    return component;
-}
-let layoutComponent = null;
-let layoutLoader = null;
-export function resolveLayout(loader) {
-    if (layoutLoader !== loader || !layoutComponent) {
-        layoutComponent = lazy(loader);
-        layoutLoader = loader;
-    }
-    return layoutComponent;
-}
-const nestedLayoutCache = new Map();
-export function nestedLayout(loader) {
-    let component = nestedLayoutCache.get(loader);
-    if (!component) {
-        component = lazy(loader);
-        nestedLayoutCache.set(loader, component);
-    }
-    return component;
-}
-let notFoundComponent = null;
-let notFoundLoader = null;
-export function resolveNotFound(loader) {
-    if (notFoundLoader !== loader || !notFoundComponent) {
-        notFoundComponent = lazy(loader);
-        notFoundLoader = loader;
-    }
-    return notFoundComponent;
-}

package/build/client/match.d.ts

@@ -1,2 +0,0 @@
-export type RouteParams = Record<string, string>;
-export declare function matchRoute(pattern: string, pathname: string): RouteParams | null;

package/build/client/match.js

@@ -1,32 +0,0 @@
-export function matchRoute(pattern, pathname) {
-    const patternSegs = pattern.split('/').filter(Boolean);
-    const pathSegs = pathname.split('/').filter(Boolean);
-    const params = {};
-    for (let i = 0; i < patternSegs.length; i++) {
-        const p = patternSegs[i];
-        if (p.startsWith('**')) {
-            params[p.slice(2)] = pathSegs
-                .slice(i)
-                .map((s) => decodeURIComponent(s))
-                .join('/');
-            return params;
-        }
-        if (p.startsWith('*')) {
-            const rest = pathSegs.slice(i);
-            if (rest.length === 0)
-                return null;
-            params[p.slice(1)] = rest.map((s) => decodeURIComponent(s)).join('/');
-            return params;
-        }
-        if (i >= pathSegs.length)
-            return null;
-        const value = pathSegs[i];
-        if (p.startsWith(':')) {
-            params[p.slice(1)] = decodeURIComponent(value);
-        }
-        else if (p !== value) {
-            return null;
-        }
-    }
-    return patternSegs.length === pathSegs.length ? params : null;
-}

package/build/client/mount.d.ts

@@ -1,2 +0,0 @@
-import type { LayoutLoader, NotFoundLoader, RouteDef } from './types.js';
-export declare function mount(routes: RouteDef[], layout?: LayoutLoader, notFound?: NotFoundLoader): void;

package/build/client/mount.js

@@ -1,13 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createRoot } from 'react-dom/client';
-import { initNavigation } from './navigation.js';
-import { startPrefetcher } from './prefetch.js';
-import { Router } from './Router.js';
-export function mount(routes, layout = null, notFound = null) {
-    const el = document.getElementById('root');
-    if (!el)
-        throw new Error('toil: #root element not found');
-    initNavigation();
-    createRoot(el).render(_jsx(Router, { routes: routes, layout: layout, notFound: notFound }));
-    startPrefetcher(routes);
-}

package/build/client/navigation.d.ts

@@ -1,13 +0,0 @@
-export declare function settleNavigation(): void;
-export declare function isNavigationPending(): boolean;
-export declare function subscribePending(listener: () => void): () => void;
-export interface NavigateOptions {
-    readonly replace?: boolean;
-    readonly scroll?: boolean;
-}
-export declare function initNavigation(): void;
-export declare function navigate(href: string, options?: NavigateOptions): void;
-export declare function back(): void;
-export declare function forward(): void;
-export declare function refresh(): void;
-export declare function subscribeLocation(listener: () => void): () => void;

package/build/client/navigation.js

@@ -1,97 +0,0 @@
-import { enableManualScrollRestoration, planScroll, rememberScroll, } from './scroll.js';
-const listeners = new Set();
-let popstateBound = false;
-let keyCounter = 0;
-let currentKey = 'initial';
-function nextKey() {
-    keyCounter += 1;
-    return `t${String(keyCounter)}`;
-}
-function notify() {
-    for (const listener of listeners)
-        listener();
-}
-let startedTick = 0;
-let committedTick = 0;
-const pendingListeners = new Set();
-function emitPending() {
-    for (const listener of pendingListeners)
-        listener();
-}
-function beginNavigation() {
-    startedTick += 1;
-    emitPending();
-}
-export function settleNavigation() {
-    if (committedTick !== startedTick) {
-        committedTick = startedTick;
-        emitPending();
-    }
-}
-export function isNavigationPending() {
-    return startedTick !== committedTick;
-}
-export function subscribePending(listener) {
-    pendingListeners.add(listener);
-    return () => {
-        pendingListeners.delete(listener);
-    };
-}
-export function initNavigation() {
-    enableManualScrollRestoration();
-    const state = window.history.state;
-    if (state?.__toilKey) {
-        currentKey = state.__toilKey;
-    }
-    else {
-        currentKey = nextKey();
-        window.history.replaceState({ ...state, __toilKey: currentKey }, '');
-    }
-}
-export function navigate(href, options) {
-    beginNavigation();
-    rememberScroll(currentKey);
-    let hash = '';
-    try {
-        hash = new URL(href, window.location.href).hash;
-    }
-    catch {
-        hash = '';
-    }
-    if (options?.replace) {
-        window.history.replaceState({ __toilKey: currentKey }, '', href);
-    }
-    else {
-        currentKey = nextKey();
-        window.history.pushState({ __toilKey: currentKey }, '', href);
-    }
-    planScroll({ hash, toTop: options?.scroll !== false });
-    notify();
-}
-export function back() {
-    window.history.back();
-}
-export function forward() {
-    window.history.forward();
-}
-export function refresh() {
-    notify();
-}
-function handlePopState(event) {
-    beginNavigation();
-    rememberScroll(currentKey);
-    const state = event.state;
-    currentKey = state?.__toilKey ?? 'initial';
-    planScroll({ restoreKey: currentKey, hash: window.location.hash, toTop: false });
-    notify();
-}
-export function subscribeLocation(listener) {
-    if (!popstateBound) {
-        window.addEventListener('popstate', handlePopState);
-        popstateBound = true;
-    }
-    listeners.add(listener);
-    return () => {
-        listeners.delete(listener);
-    };
-}

package/build/client/params-context.d.ts

@@ -1,2 +0,0 @@
-import type { RouteParams } from './match.js';
-export declare const ParamsContext: import("react").Context<RouteParams>;

package/build/client/params-context.js

@@ -1,2 +0,0 @@
-import { createContext } from 'react';
-export const ParamsContext = createContext({});

package/build/client/prefetch.d.ts

@@ -1,11 +0,0 @@
-import type { RouteDef } from './types.js';
-declare global {
-    interface Navigator {
-        readonly connection?: {
-            readonly saveData?: boolean;
-            readonly effectiveType?: string;
-        };
-    }
-}
-export declare function prefetch(href: string): void;
-export declare function startPrefetcher(routes: RouteDef[]): void;

package/build/client/prefetch.js

@@ -1,100 +0,0 @@
-import { matchRoute } from './match.js';
-let routeTable = [];
-const warmed = new WeakSet();
-let io = null;
-let mo = null;
-function routeForHref(href) {
-    let url;
-    try {
-        url = new URL(href, window.location.href);
-    }
-    catch {
-        return null;
-    }
-    if (url.origin !== window.location.origin)
-        return null;
-    for (const route of routeTable) {
-        if (matchRoute(route.pattern, url.pathname))
-            return route;
-    }
-    return null;
-}
-function warm(route) {
-    if (warmed.has(route))
-        return;
-    warmed.add(route);
-    void route.load().catch(() => {
-        warmed.delete(route);
-    });
-}
-export function prefetch(href) {
-    const route = routeForHref(href);
-    if (route)
-        warm(route);
-}
-function isPrefetchable(a) {
-    if (a.target && a.target !== '_self')
-        return false;
-    if (a.hasAttribute('download'))
-        return false;
-    if (a.dataset.noPrefetch !== undefined)
-        return false;
-    return true;
-}
-function observeAnchor(a) {
-    if (!io || !isPrefetchable(a) || !routeForHref(a.href))
-        return;
-    io.observe(a);
-}
-function scan(root) {
-    root.querySelectorAll('a[href]').forEach((el) => {
-        if (el instanceof HTMLAnchorElement)
-            observeAnchor(el);
-    });
-}
-function shouldSkipForConnection() {
-    const c = navigator.connection;
-    if (!c)
-        return false;
-    return c.saveData === true || c.effectiveType === 'slow-2g' || c.effectiveType === '2g';
-}
-export function startPrefetcher(routes) {
-    routeTable = routes;
-    if (typeof window === 'undefined' ||
-        typeof IntersectionObserver === 'undefined' ||
-        typeof MutationObserver === 'undefined' ||
-        io) {
-        return;
-    }
-    if (shouldSkipForConnection())
-        return;
-    io = new IntersectionObserver((entries) => {
-        for (const entry of entries) {
-            if (!entry.isIntersecting)
-                continue;
-            const a = entry.target;
-            if (a instanceof HTMLAnchorElement) {
-                io?.unobserve(a);
-                prefetch(a.href);
-            }
-        }
-    }, { rootMargin: '200px' });
-    mo = new MutationObserver((mutations) => {
-        for (const m of mutations) {
-            for (const node of m.addedNodes) {
-                if (node instanceof HTMLAnchorElement)
-                    observeAnchor(node);
-                else if (node instanceof Element)
-                    scan(node);
-            }
-        }
-    });
-    const begin = () => {
-        scan(document);
-        mo?.observe(document.body, { childList: true, subtree: true });
-    };
-    if (typeof requestIdleCallback === 'function')
-        requestIdleCallback(begin);
-    else
-        setTimeout(begin, 200);
-}