@solidjs/router 0.4.2

package/dist/utils.js

@@ -0,0 +1,132 @@
+import { createMemo, getOwner, runWithOwner } from "solid-js";
+const hasSchemeRegex = /^(?:[a-z0-9]+:)?\/\//i;
+const trimPathRegex = /^\/+|\/+$/g;
+function normalize(path, omitSlash = false) {
+    const s = path.replace(trimPathRegex, "");
+    return s ? (omitSlash || /^[?#]/.test(s) ? s : "/" + s) : "";
+}
+export function resolvePath(base, path, from) {
+    if (hasSchemeRegex.test(path)) {
+        return undefined;
+    }
+    const basePath = normalize(base);
+    const fromPath = from && normalize(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 || "/") + normalize(path, !result);
+}
+export function invariant(value, message) {
+    if (value == null) {
+        throw new Error(message);
+    }
+    return value;
+}
+export function joinPaths(from, to) {
+    return normalize(from).replace(/\/*(\*.*)?$/g, "") + normalize(to);
+}
+export function extractSearchParams(url) {
+    const params = {};
+    url.searchParams.forEach((value, key) => {
+        params[key] = value;
+    });
+    return params;
+}
+export function urlDecode(str, isQuery) {
+    return decodeURIComponent(isQuery ? str.replace(/\+/g, " ") : str);
+}
+export function createMatcher(path, partial) {
+    const [pattern, splat] = path.split("/*", 2);
+    const segments = pattern.split("/").filter(Boolean);
+    const len = segments.length;
+    return (location) => {
+        const locSegments = location.split("/").filter(Boolean);
+        const lenDiff = locSegments.length - len;
+        if (lenDiff < 0 || (lenDiff > 0 && splat === undefined && !partial)) {
+            return null;
+        }
+        const match = {
+            path: len ? "" : "/",
+            params: {}
+        };
+        for (let i = 0; i < len; i++) {
+            const segment = segments[i];
+            const locSegment = locSegments[i];
+            if (segment[0] === ":") {
+                match.params[segment.slice(1)] = locSegment;
+            }
+            else if (segment.localeCompare(locSegment, undefined, { sensitivity: "base" }) !== 0) {
+                return null;
+            }
+            match.path += `/${locSegment}`;
+        }
+        if (splat) {
+            match.params[splat] = lenDiff ? locSegments.slice(-lenDiff).join("/") : "";
+        }
+        return match;
+    };
+}
+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());
+        }
+    });
+}
+export function mergeSearchString(search, params) {
+    const merged = new URLSearchParams(search);
+    Object.entries(params).forEach(([key, value]) => {
+        if (value == null || value === "") {
+            merged.delete(key);
+        }
+        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)], []);
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@solidjs/router",
+  "description": "Universal router for SolidJS",
+  "author": "Ryan Carniato",
+  "contributors": [
+    "Ryan Turnquist"
+  ],
+  "license": "MIT",
+  "version": "0.4.2",
+  "homepage": "https://github.com/solidjs/solid-router#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/solidjs/solid-router"
+  },
+  "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": "tsc && rollup -c",
+    "prepublishOnly": "npm run build",
+    "test": "jest && npm run test:types",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage && npm run test:types",
+    "test:types": "tsc --project tsconfig.test.json",
+    "pretty": "prettier --write \"{src,test}/**/*.{ts,tsx}\""
+  },
+  "devDependencies": {
+    "@babel/core": "^7.15.8",
+    "@babel/preset-typescript": "^7.15.0",
+    "@rollup/plugin-babel": "5.3.0",
+    "@rollup/plugin-node-resolve": "13.0.5",
+    "@types/jest": "^27.0.2",
+    "@types/node": "^16.10.3",
+    "babel-preset-solid": "^1.4.4",
+    "jest": "^27.2.5",
+    "prettier": "^2.5.1",
+    "rollup": "^2.52.1",
+    "rollup-plugin-terser": "^7.0.2",
+    "solid-jest": "^0.2.0",
+    "solid-js": "^1.4.4",
+    "typescript": "^4.5.4"
+  },
+  "peerDependencies": {
+    "solid-js": "^1.3.5"
+  },
+  "jest": {
+    "preset": "solid-jest/preset/browser"
+  }
+}