stateshape 0.2.0

package/src/types/URLData.ts

@@ -0,0 +1,10 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { LocationValue } from "./LocationValue.ts";
+import type { URLComponents } from "./URLComponents.ts";
+import type { URLSchema } from "./URLSchema.ts";
+
+export type URLData<T extends LocationValue = LocationValue> = T extends {
+  _schema: URLSchema;
+}
+  ? StandardSchemaV1.InferOutput<T["_schema"]>
+  : URLComponents;

package/src/types/URLSchema.ts

@@ -0,0 +1,4 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { URLComponents } from "./URLComponents.ts";
+
+export type URLSchema = StandardSchemaV1<URLComponents>;

package/src/utils/compileURL.ts

@@ -0,0 +1,27 @@
+import { QuasiURL } from "quasiurl";
+import type { LocationValue } from "../types/LocationValue.ts";
+import type { URLData } from "../types/URLData.ts";
+import { isLocationObject } from "./isLocationObject.ts";
+
+export function compileURL<T extends LocationValue>(
+  urlPattern: T,
+  data?: URLData<T>,
+) {
+  if (isLocationObject(urlPattern)) return urlPattern.compile(data);
+
+  let url = new QuasiURL(urlPattern ?? "");
+  let query = data?.query;
+
+  if (query) {
+    url.search = new URLSearchParams(
+      // Remove null und undefined values, stringify nonstring values
+      Object.entries(query).reduce<Record<string, string>>((p, [k, v]) => {
+        if (v !== null && v !== undefined)
+          p[k] = typeof v === "string" ? v : JSON.stringify(v);
+        return p;
+      }, {}),
+    );
+  }
+
+  return url.href;
+}

package/src/utils/getNavigationOptions.ts

@@ -0,0 +1,15 @@
+import type { LinkElement } from "../types/LinkElement.ts";
+import type { NavigationOptions } from "../types/NavigationOptions.ts";
+
+export function getNavigationOptions(element: LinkElement) {
+  let { id, spa, history, scroll } = element.dataset;
+
+  return {
+    href: element.getAttribute("href"),
+    target: element.getAttribute("target"),
+    spa,
+    history,
+    scroll,
+    id,
+  } as NavigationOptions;
+}

package/src/utils/isLocationObject.ts

@@ -0,0 +1,11 @@
+import type { LocationObject } from "../types/LocationObject.ts";
+
+export function isLocationObject(x: unknown): x is LocationObject {
+  return (
+    x !== null &&
+    typeof x === "object" &&
+    "exec" in x &&
+    "compile" in x &&
+    "_schema" in x
+  );
+}

package/src/utils/isRouteEvent.ts

@@ -0,0 +1,11 @@
+export function isRouteEvent(event: unknown) {
+  return (
+    event !== null &&
+    typeof event === "object" &&
+    (!("button" in event) || event.button === 0) &&
+    (!("ctrlKey" in event) || !event.ctrlKey) &&
+    (!("shiftKey" in event) || !event.shiftKey) &&
+    (!("altKey" in event) || !event.altKey) &&
+    (!("metaKey" in event) || !event.metaKey)
+  );
+}

package/src/utils/matchURL.ts

@@ -0,0 +1,99 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import { QuasiURL } from "quasiurl";
+import type { LocationPattern } from "../types/LocationPattern.ts";
+import type { MatchState } from "../types/MatchState.ts";
+import type { URLComponents } from "../types/URLComponents.ts";
+import type { URLSchema } from "../types/URLSchema.ts";
+import { isLocationObject } from "./isLocationObject.ts";
+
+function toObject(x: string[]) {
+  return x.reduce<Record<string, string>>((p, v, k) => {
+    p[String(k)] = v;
+
+    return p;
+  }, {});
+}
+
+function matchPattern<P extends LocationPattern>(pattern: P, href: string) {
+  let query = Object.fromEntries(
+    new URLSearchParams(new QuasiURL(href).search),
+  );
+
+  if (typeof pattern === "string")
+    return {
+      ok: pattern === "*" || pattern === href,
+      href,
+      params: {},
+      query,
+    };
+
+  if (pattern instanceof RegExp) {
+    let matches = pattern.exec(href);
+
+    return {
+      ok: matches !== null,
+      href,
+      params: matches
+        ? {
+            ...toObject(Array.from(matches).slice(1)),
+            ...matches.groups,
+          }
+        : {},
+      query,
+    };
+  }
+
+  if (isLocationObject(pattern)) {
+    let result = pattern.exec(href) as
+      | (P extends {
+          _schema: URLSchema;
+        }
+          ? StandardSchemaV1.InferOutput<P["_schema"]>
+          : URLComponents)
+      | null;
+
+    if (result === null)
+      return {
+        ok: false,
+        href,
+        params: {},
+        query: {},
+      };
+
+    return {
+      ok: true,
+      href,
+      params: result.params ?? {},
+      query: result.query ?? {},
+    };
+  }
+
+  return {
+    ok: false,
+    href,
+    params: {},
+    query: {},
+  };
+}
+
+export function matchURL<P extends LocationPattern>(
+  pattern: P,
+  href: string,
+): MatchState<P> {
+  if (Array.isArray(pattern)) {
+    for (let p of pattern) {
+      let result = matchPattern(p, href);
+
+      if (result.ok) return result as MatchState<P>;
+    }
+
+    return {
+      ok: false,
+      href,
+      params: {},
+      query: {},
+    } as MatchState<P>;
+  }
+
+  return matchPattern(pattern, href) as MatchState<P>;
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "include": ["./index.ts", "./playwright.config.ts", "./tests", "./src"],
+  "compilerOptions": {
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "lib": ["ESNext", "DOM"],
+    "target": "esnext",
+    "outDir": "dist",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "allowImportingTsExtensions": true,
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true
+  }
+}