npm - @pauloevpr/solid-router - Versions diffs - 0.16.2-vt.1 - Mend

@pauloevpr/solid-router 0.16.2-vt.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (44) hide show

package/LICENSE +21 -0
package/README.md +1097 -0
package/dist/components.d.ts +31 -0
package/dist/components.jsx +40 -0
package/dist/data/action.d.ts +17 -0
package/dist/data/action.js +166 -0
package/dist/data/createAsync.d.ts +32 -0
package/dist/data/createAsync.js +96 -0
package/dist/data/events.d.ts +9 -0
package/dist/data/events.js +123 -0
package/dist/data/index.d.ts +4 -0
package/dist/data/index.js +4 -0
package/dist/data/query.d.ts +23 -0
package/dist/data/query.js +232 -0
package/dist/data/response.d.ts +4 -0
package/dist/data/response.js +42 -0
package/dist/index.d.ts +8 -0
package/dist/index.js +2055 -0
package/dist/index.jsx +7 -0
package/dist/lifecycle.d.ts +5 -0
package/dist/lifecycle.js +76 -0
package/dist/routers/HashRouter.d.ts +9 -0
package/dist/routers/HashRouter.js +41 -0
package/dist/routers/MemoryRouter.d.ts +24 -0
package/dist/routers/MemoryRouter.js +57 -0
package/dist/routers/Router.d.ts +9 -0
package/dist/routers/Router.js +45 -0
package/dist/routers/StaticRouter.d.ts +6 -0
package/dist/routers/StaticRouter.js +15 -0
package/dist/routers/components.d.ts +29 -0
package/dist/routers/components.jsx +122 -0
package/dist/routers/createRouter.d.ts +10 -0
package/dist/routers/createRouter.js +41 -0
package/dist/routers/index.d.ts +11 -0
package/dist/routers/index.js +6 -0
package/dist/routing.d.ts +176 -0
package/dist/routing.js +608 -0
package/dist/types.d.ts +203 -0
package/dist/types.js +1 -0
package/dist/utils.d.ts +13 -0
package/dist/utils.js +193 -0
package/dist/viewTransitions.d.ts +20 -0
package/dist/viewTransitions.js +118 -0
package/package.json +71 -0

package/dist/types.d.ts ADDED Viewed

@@ -0,0 +1,203 @@
+import type { Component, JSX, Signal } from "solid-js";
+declare module "solid-js/web" {
+    interface RequestEvent {
+        response: {
+            status?: number;
+            statusText?: string;
+            headers: Headers;
+        };
+        router?: {
+            matches?: OutputMatch[];
+            cache?: Map<string, CacheEntry>;
+            submission?: {
+                input: any;
+                result: any;
+                url: string;
+            };
+            dataOnly?: boolean | string[];
+            data?: Record<string, any>;
+            previousUrl?: string;
+        };
+        serverOnly?: boolean;
+    }
+}
+export type Params = Record<string, string | undefined>;
+export type SearchParams = Record<string, string | string[] | undefined>;
+export type SetParams = Record<string, string | number | boolean | null | undefined>;
+export type SetSearchParams = Record<string, string | string[] | number | number[] | boolean | boolean[] | null | undefined>;
+export interface Path {
+    pathname: string;
+    search: string;
+    hash: string;
+}
+export interface Location<S = unknown> extends Path {
+    query: SearchParams;
+    state: Readonly<Partial<S>> | null;
+    key: string;
+}
+export interface NavigateOptions<S = unknown> {
+    resolve: boolean;
+    replace: boolean;
+    scroll: boolean;
+    state: S;
+}
+export interface Navigator {
+    (to: string | number, options?: Partial<NavigateOptions>): void;
+    (delta: number): void;
+}
+export type NavigatorFactory = (route?: RouteContext) => Navigator;
+export interface LocationChange<S = unknown> {
+    value: string;
+    replace?: boolean;
+    scroll?: boolean;
+    state?: S;
+    rawPath?: string;
+}
+export interface RouterIntegration {
+    signal: Signal<LocationChange>;
+    create?: (router: RouterContext) => void;
+    utils?: Partial<RouterUtils>;
+}
+export type Intent = "initial" | "native" | "navigate" | "preload";
+export interface RoutePreloadFuncArgs {
+    params: Params;
+    location: Location;
+    intent: Intent;
+}
+export type RoutePreloadFunc<T = unknown> = (args: RoutePreloadFuncArgs) => T;
+export interface RouteSectionProps<T = unknown> {
+    params: Params;
+    location: Location;
+    data: T;
+    children?: JSX.Element;
+}
+export type RouteSectionComponent<T = unknown> = Component<RouteSectionProps<T>> | Component<Omit<RouteSectionProps<T>, "children">> | Component<{}>;
+export type RouteDefinition<S extends string | string[] = any, T = any> = {
+    path?: S;
+    matchFilters?: MatchFilters<S>;
+    preload?: RoutePreloadFunc<T>;
+    children?: RouteDefinition | RouteDefinition[];
+    component?: RouteSectionComponent<T>;
+    info?: Record<string, any>;
+    /** @deprecated use preload */
+    load?: RoutePreloadFunc;
+};
+export type MatchFilter = readonly string[] | RegExp | ((s: string) => boolean);
+export type PathParams<P extends string | readonly string[]> = P extends `${infer Head}/${infer Tail}` ? [...PathParams<Head>, ...PathParams<Tail>] : P extends `:${infer S}?` ? [S] : P extends `:${infer S}` ? [S] : P extends `*${infer S}` ? [S] : [];
+export type MatchFilters<P extends string | readonly string[] = any> = P extends string ? {
+    [K in PathParams<P>[number]]?: MatchFilter;
+} : Record<string, MatchFilter>;
+export interface PathMatch {
+    params: Params;
+    path: string;
+}
+export interface RouteMatch extends PathMatch {
+    route: RouteDescription;
+}
+export interface OutputMatch {
+    path: string;
+    pattern: string;
+    match: string;
+    params: Params;
+    info?: Record<string, any>;
+}
+export interface RouteDescription {
+    key: unknown;
+    originalPath: string;
+    pattern: string;
+    component?: Component<RouteSectionProps>;
+    preload?: RoutePreloadFunc;
+    matcher: (location: string) => PathMatch | null;
+    matchFilters?: MatchFilters;
+    info?: Record<string, any>;
+}
+export interface Branch {
+    routes: RouteDescription[];
+    score: number;
+    matcher: (location: string) => RouteMatch[] | null;
+}
+export interface RouteContext {
+    parent?: RouteContext;
+    child?: RouteContext;
+    pattern: string;
+    path: () => string;
+    outlet: () => JSX.Element;
+    resolvePath(to: string): string | undefined;
+}
+export interface RouterUtils {
+    renderPath(path: string): string;
+    parsePath(str: string): string;
+    go(delta: number): void;
+    beforeLeave: BeforeLeaveLifecycle;
+    paramsWrapper: (getParams: () => Params, branches: () => Branch[]) => Params;
+    queryWrapper: (getQuery: () => SearchParams) => SearchParams;
+}
+export interface RouterContext {
+    base: RouteContext;
+    location: Location;
+    params: Params;
+    navigatorFactory: NavigatorFactory;
+    isRouting: () => boolean;
+    /** The target of the in-flight navigation transition, if any. Not reactive. */
+    readonly pendingTarget?: LocationChange;
+    matches: () => RouteMatch[];
+    renderPath(path: string): string;
+    parsePath(str: string): string;
+    beforeLeave: BeforeLeaveLifecycle;
+    preloadRoute: (url: URL, preloadData?: boolean) => void;
+    singleFlight: boolean;
+    submissions: Signal<Submission<any, any>[]>;
+}
+export interface BeforeLeaveEventArgs {
+    from: Location;
+    to: string | number;
+    options?: Partial<NavigateOptions>;
+    readonly defaultPrevented: boolean;
+    preventDefault(): void;
+    retry(force?: boolean): void;
+}
+export interface BeforeLeaveListener {
+    listener(e: BeforeLeaveEventArgs): void;
+    location: Location;
+    navigate: Navigator;
+}
+export interface BeforeLeaveLifecycle {
+    subscribe(listener: BeforeLeaveListener): () => void;
+    confirm(to: string | number, options?: Partial<NavigateOptions>): boolean;
+}
+export type Submission<T, U> = {
+    readonly input: T;
+    readonly result?: U;
+    readonly error: any;
+    readonly pending: boolean;
+    readonly url: string;
+    clear: () => void;
+    retry: () => void;
+};
+export type SubmissionStub = {
+    readonly input: undefined;
+    readonly result: undefined;
+    readonly error: undefined;
+    readonly pending: undefined;
+    readonly url: undefined;
+    clear: () => void;
+    retry: () => void;
+};
+export interface MaybePreloadableComponent extends Component {
+    preload?: () => void;
+}
+export type CacheEntry = [number, Promise<any>, any, Intent | undefined, Signal<number> & {
+    count: number;
+}];
+export type NarrowResponse<T> = T extends CustomResponse<infer U> ? U : Exclude<T, Response>;
+export type RouterResponseInit = Omit<ResponseInit, "body"> & {
+    revalidate?: string | string[];
+};
+export type CustomResponse<T> = Omit<Response, "clone"> & {
+    customBody: () => T;
+    clone(...args: readonly unknown[]): CustomResponse<T>;
+};
+/** @deprecated */
+export type RouteLoadFunc = RoutePreloadFunc;
+/** @deprecated */
+export type RouteLoadFuncArgs = RoutePreloadFuncArgs;

package/dist/types.js ADDED Viewed

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

package/dist/utils.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import type { MatchFilters, PathMatch, RouteDescription, SearchParams, SetSearchParams } from "./types.js";
+export declare const mockBase = "http://sr";
+export declare function normalizePath(path: string, omitSlash?: boolean): string;
+export declare function resolvePath(base: string, path: string, from?: string): string | undefined;
+export declare function invariant<T>(value: T | null | undefined, message: string): T;
+export declare function joinPaths(from: string, to: string): string;
+export declare function extractSearchParams(url: URL): SearchParams;
+export declare function createMatcher<S extends string>(path: S, partial?: boolean, matchFilters?: MatchFilters<S>): (location: string) => PathMatch | null;
+export declare function scoreRoute(route: RouteDescription): number;
+export declare function createMemoObject<T extends Record<string | symbol, unknown>>(fn: () => T): T;
+export declare function mergeSearchString(search: string, params: SetSearchParams): string;
+export declare function expandOptionals(pattern: string): string[];
+export declare function setFunctionName<T>(obj: T, value: string): T;

package/dist/utils.js ADDED Viewed

@@ -0,0 +1,193 @@
+import { createMemo, getOwner, runWithOwner } from "solid-js";
+const hasSchemeRegex = /^(?:[a-z0-9]+:)?\/\//i;
+const trimPathRegex = /^\/+|(\/)\/+$/g;
+export const mockBase = "http://sr";
+export function normalizePath(path, omitSlash = false) {
+    const s = path.replace(trimPathRegex, "$1");
+    return s ? (omitSlash || /^[?#]/.test(s) ? s : "/" + s) : "";
+}
+export function resolvePath(base, path, from) {
+    if (hasSchemeRegex.test(path)) {
+        return undefined;
+    }
+    const basePath = normalizePath(base);
+    const fromPath = from && normalizePath(from);
+    let result = "";
+    if (!fromPath || path.startsWith("/")) {
+        result = basePath;
+    }
+    else if (fromPath.toLowerCase().indexOf(basePath.toLowerCase()) !== 0) {
+        result = basePath + fromPath;
+    }
+    else {
+        result = fromPath;
+    }
+    return (result || "/") + normalizePath(path, !result);
+}
+export function invariant(value, message) {
+    if (value == null) {
+        throw new Error(message);
+    }
+    return value;
+}
+export function joinPaths(from, to) {
+    return normalizePath(from).replace(/\/*(\*.*)?$/g, "") + normalizePath(to);
+}
+export function extractSearchParams(url) {
+    const params = {};
+    url.searchParams.forEach((value, key) => {
+        if (key in params) {
+            if (Array.isArray(params[key]))
+                params[key].push(value);
+            else
+                params[key] = [params[key], value];
+        }
+        else
+            params[key] = value;
+    });
+    return params;
+}
+export function createMatcher(path, partial, matchFilters) {
+    const [pattern, splat] = path.split("/*", 2);
+    const segments = pattern.split("/").filter(Boolean);
+    const len = segments.length;
+    return (location) => {
+        const locSegments = location.split("/");
+        // tolerate a single leading and trailing slash, but reject empty interior
+        // segments so `/foo//bar` doesn't silently match `/foo/bar` (#567)
+        if (locSegments[0] === "")
+            locSegments.shift();
+        if (locSegments.length && locSegments[locSegments.length - 1] === "")
+            locSegments.pop();
+        if (locSegments.includes(""))
+            return null;
+        const lenDiff = locSegments.length - len;
+        if (lenDiff < 0 || (lenDiff > 0 && splat === undefined && !partial)) {
+            return null;
+        }
+        const match = {
+            path: len ? "" : "/",
+            params: {}
+        };
+        const matchFilter = (s) => matchFilters === undefined ? undefined : matchFilters[s];
+        for (let i = 0; i < len; i++) {
+            const segment = segments[i];
+            const dynamic = segment[0] === ":";
+            const locSegment = dynamic ? locSegments[i] : locSegments[i].toLowerCase();
+            const key = dynamic ? segment.slice(1) : segment.toLowerCase();
+            if (dynamic && matchSegment(locSegment, matchFilter(key))) {
+                match.params[key] = locSegment;
+            }
+            else if (dynamic || !matchSegment(locSegment, key)) {
+                return null;
+            }
+            match.path += `/${locSegment}`;
+        }
+        if (splat) {
+            const remainder = lenDiff ? locSegments.slice(-lenDiff).join("/") : "";
+            if (matchSegment(remainder, matchFilter(splat))) {
+                match.params[splat] = remainder;
+            }
+            else {
+                return null;
+            }
+        }
+        return match;
+    };
+}
+function matchSegment(input, filter) {
+    const isEqual = (s) => s === input;
+    if (filter === undefined) {
+        return true;
+    }
+    else if (typeof filter === "string") {
+        return isEqual(filter);
+    }
+    else if (typeof filter === "function") {
+        return filter(input);
+    }
+    else if (Array.isArray(filter)) {
+        return filter.some(isEqual);
+    }
+    else if (filter instanceof RegExp) {
+        return filter.test(input);
+    }
+    return false;
+}
+export function scoreRoute(route) {
+    const [pattern, splat] = route.pattern.split("/*", 2);
+    const segments = pattern.split("/").filter(Boolean);
+    return segments.reduce((score, segment) => score + (segment.startsWith(":") ? 2 : 3), segments.length - (splat === undefined ? 0 : 1));
+}
+export function createMemoObject(fn) {
+    const map = new Map();
+    const owner = getOwner();
+    return new Proxy({}, {
+        get(_, property) {
+            if (!map.has(property)) {
+                runWithOwner(owner, () => map.set(property, createMemo(() => fn()[property])));
+            }
+            return map.get(property)();
+        },
+        getOwnPropertyDescriptor() {
+            return {
+                enumerable: true,
+                configurable: true
+            };
+        },
+        ownKeys() {
+            return Reflect.ownKeys(fn());
+        },
+        has(_, property) {
+            return property in fn();
+        }
+    });
+}
+export function mergeSearchString(search, params) {
+    const merged = new URLSearchParams(search);
+    Object.entries(params).forEach(([key, value]) => {
+        if (value == null || value === "" || (value instanceof Array && !value.length)) {
+            merged.delete(key);
+        }
+        else {
+            if (value instanceof Array) {
+                // Delete all instances of the key before appending
+                merged.delete(key);
+                value.forEach(v => {
+                    merged.append(key, String(v));
+                });
+            }
+            else {
+                merged.set(key, String(value));
+            }
+        }
+    });
+    const s = merged.toString();
+    return s ? `?${s}` : "";
+}
+export function expandOptionals(pattern) {
+    let match = /(\/?\:[^\/]+)\?/.exec(pattern);
+    if (!match)
+        return [pattern];
+    let prefix = pattern.slice(0, match.index);
+    let suffix = pattern.slice(match.index + match[0].length);
+    const prefixes = [prefix, (prefix += match[1])];
+    // This section handles adjacent optional params. We don't actually want all permuations since
+    // that will lead to equivalent routes which have the same number of params. For example
+    // `/:a?/:b?/:c`? only has the unique expansion: `/`, `/:a`, `/:a/:b`, `/:a/:b/:c` and we can
+    // discard `/:b`, `/:c`, `/:b/:c` by building them up in order and not recursing. This also helps
+    // ensure predictability where earlier params have precidence.
+    while ((match = /^(\/\:[^\/]+)\?/.exec(suffix))) {
+        prefixes.push((prefix += match[1]));
+        suffix = suffix.slice(match[0].length);
+    }
+    return expandOptionals(suffix).reduce((results, expansion) => [...results, ...prefixes.map(p => p + expansion)], []);
+}
+export function setFunctionName(obj, value) {
+    Object.defineProperty(obj, "name", {
+        value,
+        writable: false,
+        configurable: false
+    });
+    return obj;
+}

package/dist/viewTransitions.d.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import { type Accessor } from "solid-js";
+export type ViewTransitionAnimation = "exponential-smooth";
+export type ViewTransitionOptions = {
+    name: string;
+    animation?: ViewTransitionAnimation;
+};
+export type ViewTransitionSourceOptions = string | (ViewTransitionOptions & {
+    include?: string[];
+});
+export type ViewTransitionTargetOptions = string | ViewTransitionOptions;
+export declare function viewTransitionSource(element: HTMLElement, options: Accessor<ViewTransitionSourceOptions>): void;
+export declare function viewTransitionTarget(element: HTMLElement, options: Accessor<ViewTransitionTargetOptions>): void;
+declare module "solid-js" {
+    namespace JSX {
+        interface Directives {
+            viewTransitionSource: ViewTransitionSourceOptions;
+            viewTransitionTarget: ViewTransitionTargetOptions;
+        }
+    }
+}

package/dist/viewTransitions.js ADDED Viewed

@@ -0,0 +1,118 @@
+import { createEffect, createSignal, onCleanup } from "solid-js";
+export function viewTransitionSource(element, options) {
+    function select() {
+        const source = options();
+        setActiveNames(typeof source === "string" ? [source] : [source.name, ...(source.include ?? [])]);
+    }
+    element.addEventListener("click", select);
+    createEffect(() => {
+        const source = options();
+        const name = getName(source);
+        registerAnimation(name, getAnimation(source));
+        element.style.setProperty("view-transition-name", activeNames().includes(name) ? name : "none");
+    });
+    onCleanup(() => {
+        element.removeEventListener("click", select);
+        element.style.removeProperty("view-transition-name");
+    });
+}
+export function viewTransitionTarget(element, options) {
+    createEffect(() => {
+        const target = options();
+        const name = getName(target);
+        registerAnimation(name, getAnimation(target));
+        element.style.setProperty("view-transition-name", name);
+    });
+    onCleanup(() => element.style.removeProperty("view-transition-name"));
+}
+const [activeNames, setActiveNames] = createSignal([]);
+const animationNames = new Set();
+let style;
+function getName(options) {
+    return typeof options === "string" ? options : options.name;
+}
+function getAnimation(options) {
+    return typeof options === "string" ? undefined : options.animation;
+}
+function registerAnimation(name, animation) {
+    if (!animation)
+        return;
+    animationNames.add(name);
+    updateAnimationStyles();
+}
+function updateAnimationStyles() {
+    if (typeof document === "undefined" || animationNames.size === 0)
+        return;
+    style ??= document.createElement("style");
+    style.id = "solid-view-transition-animations";
+    if (!style.parentNode)
+        document.head.append(style);
+    const animations = Array.from(animationNames, name => {
+        const transitionName = CSS.escape(name);
+        return `
+::view-transition-group(${transitionName}) {
+  animation-duration: var(--solid-vt-exponential-duration);
+  animation-timing-function: var(--solid-vt-exponential-ease);
+}
+::view-transition-old(${transitionName}) {
+  animation: solid-vt-exponential-fade-out var(--solid-vt-exponential-duration) var(--solid-vt-exponential-ease) both;
+}
+::view-transition-new(${transitionName}) {
+  animation: solid-vt-exponential-fade-in var(--solid-vt-exponential-duration) var(--solid-vt-exponential-ease) both;
+}`;
+    }).join("\n");
+    style.textContent = `
+:root {
+  --solid-vt-exponential-duration: 320ms;
+  --solid-vt-exponential-ease: cubic-bezier(0.16, 1, 0.3, 1);
+}
+@supports (animation-timing-function: linear(0, 1)) {
+  :root {
+    --solid-vt-exponential-ease: linear(
+      0,
+      0.336 10%,
+      0.561 20%,
+      0.711 30%,
+      0.813 40%,
+      0.881 50%,
+      0.927 60%,
+      0.956 70%,
+      0.976 80%,
+      0.991 90%,
+      1
+    );
+  }
+}
+::view-transition-group(root),
+::view-transition-old(root),
+::view-transition-new(root) {
+  animation: none;
+}
+@keyframes solid-vt-exponential-fade-out {
+  from {
+    opacity: 1;
+  }
+  to {
+    opacity: 0;
+  }
+}
+@keyframes solid-vt-exponential-fade-in {
+  from {
+    opacity: 0;
+  }
+  to {
+    opacity: 1;
+  }
+}
+${animations}
+`;
+}

package/package.json ADDED Viewed

@@ -0,0 +1,71 @@
+{
+  "name": "@pauloevpr/solid-router",
+  "description": "Solid Router with native View Transitions API support",
+  "keywords": [
+    "solid",
+    "router",
+    "view-transitions"
+  ],
+  "author": "Ryan Carniato",
+  "contributors": [
+    "Ryan Turnquist"
+  ],
+  "license": "MIT",
+  "version": "0.16.2-vt.1",
+  "homepage": "https://github.com/pauloevpr/solid-router#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pauloevpr/solid-router"
+  },
+  "bugs": {
+    "url": "https://github.com/pauloevpr/solid-router/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "solid": "./dist/index.jsx",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "rm -rf dist && tsc && rollup -c",
+    "prepublishOnly": "npm test && npm run build",
+    "test": "vitest run && npm run test:types",
+    "test:watch": "vitest",
+    "test:types": "tsc --project tsconfig.test.json",
+    "pretty": "prettier --write \"{src,test}/**/*.{ts,tsx}\"",
+    "release": "pnpm build && changeset publish"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.26.0",
+    "@babel/preset-typescript": "^7.26.0",
+    "@changesets/cli": "^2.27.10",
+    "@rollup/plugin-babel": "6.0.4",
+    "@rollup/plugin-node-resolve": "15.3.0",
+    "@rollup/plugin-terser": "0.4.4",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.10.0",
+    "babel-preset-solid": "^1.9.3",
+    "jsdom": "^25.0.1",
+    "prettier": "^3.4.1",
+    "rollup": "^4.27.4",
+    "solid-js": "^1.9.3",
+    "typescript": "^5.7.2",
+    "vite": "^6.0.0",
+    "vite-plugin-solid": "^2.11.0",
+    "vitest": "^2.1.6"
+  },
+  "peerDependencies": {
+    "solid-js": "^1.8.6"
+  },
+  "packageManager": "pnpm@10.19.0+sha512.c9fc7236e92adf5c8af42fd5bf1612df99c2ceb62f27047032f4720b33f8eacdde311865e91c411f2774f618d82f320808ecb51718bfa82c060c4ba7c76a32b8"
+}