@richie-router/core 0.0.1 → 0.1.1

package/dist/cjs/index.cjs

@@ -0,0 +1,463 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// packages/core/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  serializeHeadConfig: () => serializeHeadConfig,
+  resolveHeadConfig: () => resolveHeadConfig,
+  redirect: () => redirect,
+  parseSearchValue: () => parseSearchValue,
+  notFound: () => notFound,
+  normalizeRouteIdRuntime: () => normalizeRouteIdRuntime,
+  mergeHeadConfigs: () => mergeHeadConfigs,
+  matchRouteTree: () => matchRouteTree,
+  matchPathname: () => matchPathname,
+  isRedirect: () => isRedirect,
+  isPathlessRoute: () => isPathlessRoute,
+  isNotFound: () => isNotFound,
+  isIndexRoute: () => isIndexRoute,
+  defineHeadTagSchema: () => defineHeadTagSchema,
+  defaultStringifySearch: () => defaultStringifySearch,
+  defaultParseSearch: () => defaultParseSearch,
+  createRouteNode: () => createRouteNode,
+  createParsedLocation: () => createParsedLocation,
+  collectRoutes: () => collectRoutes,
+  collectBranches: () => collectBranches,
+  buildPath: () => buildPath,
+  RouteNode: () => RouteNode,
+  RedirectError: () => RedirectError,
+  NotFoundError: () => NotFoundError
+});
+module.exports = __toCommonJS(exports_src);
+function defineHeadTagSchema(schema) {
+  return schema;
+}
+
+class RedirectError extends Error {
+  options;
+  constructor(options) {
+    super(`Redirect to ${options.to}`);
+    this.options = options;
+    this.name = "RedirectError";
+  }
+}
+
+class NotFoundError extends Error {
+  constructor(message = "Not Found") {
+    super(message);
+    this.name = "NotFoundError";
+  }
+}
+function redirect(options) {
+  throw new RedirectError(options);
+}
+function notFound(message) {
+  throw new NotFoundError(message);
+}
+function isRedirect(error) {
+  return error instanceof RedirectError;
+}
+function isNotFound(error) {
+  return error instanceof NotFoundError;
+}
+
+class RouteNode {
+  id;
+  fullPath;
+  to;
+  parent;
+  children = [];
+  searchSchema;
+  routeTypes;
+  isRoot;
+  options;
+  constructor(path, options, init) {
+    this.id = path;
+    this.fullPath = path;
+    this.to = normalizeRouteIdRuntime(path);
+    this.options = options;
+    this.isRoot = init?.isRoot ?? false;
+  }
+  update(config) {
+    this.id = config.id;
+    this.fullPath = config.path;
+    this.to = normalizeRouteIdRuntime(config.path);
+    this.parent = config.getParentRoute?.();
+    return this;
+  }
+  _addFileChildren(children) {
+    this.children = Object.values(children);
+    for (const child of this.children) {
+      child.parent = this;
+    }
+    return this;
+  }
+  _addFileTypes() {
+    return this;
+  }
+  _setSearchSchema(schema) {
+    this.searchSchema = schema;
+    return this;
+  }
+}
+function createRouteNode(path, options, init) {
+  return new RouteNode(path, options, init);
+}
+function normalizeRouteIdRuntime(routeId) {
+  if (routeId === "__root__" || routeId === "/") {
+    return "/";
+  }
+  const withoutTrailingSlash = routeId !== "/" && routeId.endsWith("/") ? routeId.slice(0, -1) : routeId;
+  const segments = withoutTrailingSlash.split("/").filter(Boolean).map((segment) => {
+    if (segment.startsWith("_")) {
+      return null;
+    }
+    if (segment.endsWith("_")) {
+      return segment.slice(0, -1);
+    }
+    return segment;
+  }).filter((segment) => Boolean(segment));
+  return segments.length === 0 ? "/" : `/${segments.join("/")}`;
+}
+function isIndexRoute(route) {
+  return !route.isRoot && route.fullPath.endsWith("/");
+}
+function isPathlessRoute(route) {
+  return !route.isRoot && !isIndexRoute(route) && route.parent !== undefined && route.to === route.parent.to;
+}
+function parseSearchValue(value) {
+  if (value === "") {
+    return "";
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function defaultParseSearch(searchStr) {
+  const result = {};
+  const params = new URLSearchParams(searchStr.startsWith("?") ? searchStr.slice(1) : searchStr);
+  for (const [key, value] of params.entries()) {
+    result[key] = parseSearchValue(value);
+  }
+  return result;
+}
+function defaultStringifySearch(search) {
+  const params = new URLSearchParams;
+  for (const [key, value] of Object.entries(search)) {
+    if (value === undefined) {
+      continue;
+    }
+    params.set(key, typeof value === "string" ? value : JSON.stringify(value));
+  }
+  const serialized = params.toString();
+  return serialized ? `?${serialized}` : "";
+}
+function normalizePattern(pattern) {
+  if (pattern === "/") {
+    return [];
+  }
+  return pattern.split("/").filter(Boolean);
+}
+function buildPath(to, params = {}) {
+  const normalized = normalizeRouteIdRuntime(to);
+  if (normalized === "/") {
+    return "/";
+  }
+  const segments = normalized.split("/").filter(Boolean).map((segment) => {
+    if (segment === "$") {
+      return encodeURIComponent(params._splat ?? "");
+    }
+    if (segment.startsWith("$")) {
+      const key = segment.slice(1);
+      const value = params[key];
+      if (value === undefined) {
+        throw new Error(`Missing route param "${key}" for path "${to}"`);
+      }
+      return encodeURIComponent(value);
+    }
+    return segment;
+  });
+  return `/${segments.join("/")}`;
+}
+function matchPathname(pattern, pathname, options) {
+  const patternSegments = normalizePattern(normalizeRouteIdRuntime(pattern));
+  const pathnameSegments = normalizePattern(pathname);
+  const params = {};
+  if (patternSegments.length === 0) {
+    if (!options?.partial && pathnameSegments.length > 0) {
+      return null;
+    }
+    return { params };
+  }
+  let pathnameIndex = 0;
+  for (let patternIndex = 0;patternIndex < patternSegments.length; patternIndex += 1) {
+    const segment = patternSegments[patternIndex];
+    if (segment === undefined) {
+      return null;
+    }
+    if (segment === "$") {
+      params._splat = decodeURIComponent(pathnameSegments.slice(pathnameIndex).join("/"));
+      pathnameIndex = pathnameSegments.length;
+      break;
+    }
+    const current = pathnameSegments[pathnameIndex];
+    if (current === undefined) {
+      return null;
+    }
+    if (segment.startsWith("$")) {
+      params[segment.slice(1)] = decodeURIComponent(current);
+      pathnameIndex += 1;
+      continue;
+    }
+    if (segment !== current) {
+      return null;
+    }
+    pathnameIndex += 1;
+  }
+  if (!options?.partial && pathnameIndex < pathnameSegments.length) {
+    return null;
+  }
+  return { params };
+}
+function scorePattern(pattern) {
+  return normalizePattern(pattern).reduce((score, segment) => {
+    if (segment === "$") {
+      return score + 1;
+    }
+    if (segment.startsWith("$")) {
+      return score + 2;
+    }
+    return score + 3;
+  }, 0);
+}
+function canTerminate(route) {
+  if (route.isRoot || isPathlessRoute(route)) {
+    return false;
+  }
+  if (route.children.length === 0) {
+    return true;
+  }
+  return !route.children.some((child) => isIndexRoute(child));
+}
+function collectBranches(routeTree) {
+  const branches = [];
+  function walk(route, ancestors) {
+    const nextAncestors = [...ancestors, route];
+    if (canTerminate(route)) {
+      branches.push({
+        leaf: route,
+        routes: nextAncestors,
+        score: scorePattern(route.to) + nextAncestors.length
+      });
+    }
+    for (const child of route.children) {
+      walk(child, nextAncestors);
+    }
+  }
+  walk(routeTree, []);
+  return branches.sort((left, right) => right.score - left.score);
+}
+function collectRoutes(routeTree) {
+  const routes = [];
+  function walk(route) {
+    routes.push(route);
+    for (const child of route.children) {
+      walk(child);
+    }
+  }
+  walk(routeTree);
+  return routes;
+}
+function matchRouteTree(routeTree, pathname) {
+  const branches = collectBranches(routeTree);
+  for (const branch of branches) {
+    const leafMatch = matchPathname(branch.leaf.to, pathname);
+    if (!leafMatch) {
+      continue;
+    }
+    const matched = branch.routes.map((route) => {
+      const partialMatch = matchPathname(route.to, pathname, {
+        partial: route !== branch.leaf
+      });
+      return {
+        route,
+        params: partialMatch?.params ?? {}
+      };
+    });
+    return matched;
+  }
+  return null;
+}
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function renderAttributes(attributes) {
+  return Object.entries(attributes).flatMap(([key, value]) => {
+    if (value === undefined || value === false) {
+      return [];
+    }
+    if (value === true) {
+      return [key];
+    }
+    return [`${key}="${escapeHtml(value)}"`];
+  }).join(" ");
+}
+function mergeHeadConfigs(heads) {
+  const titles = [];
+  const metaByKey = new Map;
+  const linksByKey = new Map;
+  const styles = [];
+  const scripts = [];
+  for (const head of heads) {
+    for (const meta of head.meta ?? []) {
+      if ("title" in meta) {
+        titles.push(meta);
+        continue;
+      }
+      if ("charset" in meta) {
+        metaByKey.set("charset", meta);
+        continue;
+      }
+      if ("name" in meta) {
+        metaByKey.set(`name:${meta.name}`, meta);
+        continue;
+      }
+      if ("property" in meta) {
+        metaByKey.set(`property:${meta.property}`, meta);
+        continue;
+      }
+      metaByKey.set(`httpEquiv:${meta.httpEquiv}`, meta);
+    }
+    for (const link of head.links ?? []) {
+      linksByKey.set(`${link.rel}:${link.href}`, link);
+    }
+    styles.push(...head.styles ?? []);
+    scripts.push(...head.scripts ?? []);
+  }
+  const title = titles.at(-1);
+  return {
+    meta: [...title ? [title] : [], ...metaByKey.values()],
+    links: [...linksByKey.values()],
+    styles,
+    scripts
+  };
+}
+function resolveInlineHead(match, matches) {
+  const headOption = match.route.options.head;
+  if (!headOption || typeof headOption === "string") {
+    return null;
+  }
+  return typeof headOption === "function" ? headOption({
+    params: match.params,
+    search: match.search,
+    matches
+  }) : headOption;
+}
+function resolveHeadConfig(matches, resolvedHeadByRoute) {
+  const heads = [];
+  for (const match of matches) {
+    const resolvedHead = resolvedHeadByRoute?.get(match.route.fullPath);
+    if (resolvedHead) {
+      heads.push(resolvedHead);
+    }
+    const inlineHead = resolveInlineHead(match, matches);
+    if (inlineHead) {
+      heads.push(inlineHead);
+    }
+  }
+  return mergeHeadConfigs(heads);
+}
+function serializeHeadConfig(head, options) {
+  const managedAttributes = options?.managedAttribute ? {
+    [options.managedAttribute]: "true"
+  } : {};
+  const meta = (head.meta ?? []).map((tag) => {
+    if ("title" in tag) {
+      return `<title ${renderAttributes(managedAttributes)}>${escapeHtml(tag.title)}</title>`;
+    }
+    if ("charset" in tag) {
+      return `<meta ${renderAttributes({ charset: tag.charset, ...managedAttributes })}>`;
+    }
+    if ("name" in tag) {
+      return `<meta ${renderAttributes({ name: tag.name, content: tag.content, ...managedAttributes })}>`;
+    }
+    if ("property" in tag) {
+      return `<meta ${renderAttributes({ property: tag.property, content: tag.content, ...managedAttributes })}>`;
+    }
+    return `<meta ${renderAttributes({ "http-equiv": tag.httpEquiv, content: tag.content, ...managedAttributes })}>`;
+  });
+  const links = (head.links ?? []).map((link) => `<link ${renderAttributes({
+    rel: link.rel,
+    href: link.href,
+    type: link.type,
+    media: link.media,
+    sizes: link.sizes,
+    crossorigin: link.crossorigin,
+    ...managedAttributes
+  })}>`);
+  const styles = (head.styles ?? []).map((style) => {
+    const attributes = renderAttributes({ media: style.media, ...managedAttributes });
+    return `<style${attributes ? ` ${attributes}` : ""}>${style.children}</style>`;
+  });
+  const scripts = (head.scripts ?? []).map((script) => {
+    const attributes = renderAttributes({
+      src: script.src,
+      type: script.type,
+      async: script.async,
+      defer: script.defer,
+      ...managedAttributes
+    });
+    return `<script${attributes ? ` ${attributes}` : ""}>${script.children ?? ""}</script>`;
+  });
+  return [...meta, ...links, ...styles, ...scripts].join("");
+}
+function createParsedLocation(href, state, parseSearch) {
+  const base = href.startsWith("http://") || href.startsWith("https://") ? href : `http://richie-router.local${href}`;
+  const url = new URL(base);
+  return {
+    pathname: url.pathname,
+    search: parseSearch(url.search),
+    searchStr: url.search,
+    hash: url.hash,
+    href: `${url.pathname}${url.search}${url.hash}`,
+    state
+  };
+}

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/esm/index.mjs

@@ -0,0 +1,423 @@
+// packages/core/src/index.ts
+function defineHeadTagSchema(schema) {
+  return schema;
+}
+
+class RedirectError extends Error {
+  options;
+  constructor(options) {
+    super(`Redirect to ${options.to}`);
+    this.options = options;
+    this.name = "RedirectError";
+  }
+}
+
+class NotFoundError extends Error {
+  constructor(message = "Not Found") {
+    super(message);
+    this.name = "NotFoundError";
+  }
+}
+function redirect(options) {
+  throw new RedirectError(options);
+}
+function notFound(message) {
+  throw new NotFoundError(message);
+}
+function isRedirect(error) {
+  return error instanceof RedirectError;
+}
+function isNotFound(error) {
+  return error instanceof NotFoundError;
+}
+
+class RouteNode {
+  id;
+  fullPath;
+  to;
+  parent;
+  children = [];
+  searchSchema;
+  routeTypes;
+  isRoot;
+  options;
+  constructor(path, options, init) {
+    this.id = path;
+    this.fullPath = path;
+    this.to = normalizeRouteIdRuntime(path);
+    this.options = options;
+    this.isRoot = init?.isRoot ?? false;
+  }
+  update(config) {
+    this.id = config.id;
+    this.fullPath = config.path;
+    this.to = normalizeRouteIdRuntime(config.path);
+    this.parent = config.getParentRoute?.();
+    return this;
+  }
+  _addFileChildren(children) {
+    this.children = Object.values(children);
+    for (const child of this.children) {
+      child.parent = this;
+    }
+    return this;
+  }
+  _addFileTypes() {
+    return this;
+  }
+  _setSearchSchema(schema) {
+    this.searchSchema = schema;
+    return this;
+  }
+}
+function createRouteNode(path, options, init) {
+  return new RouteNode(path, options, init);
+}
+function normalizeRouteIdRuntime(routeId) {
+  if (routeId === "__root__" || routeId === "/") {
+    return "/";
+  }
+  const withoutTrailingSlash = routeId !== "/" && routeId.endsWith("/") ? routeId.slice(0, -1) : routeId;
+  const segments = withoutTrailingSlash.split("/").filter(Boolean).map((segment) => {
+    if (segment.startsWith("_")) {
+      return null;
+    }
+    if (segment.endsWith("_")) {
+      return segment.slice(0, -1);
+    }
+    return segment;
+  }).filter((segment) => Boolean(segment));
+  return segments.length === 0 ? "/" : `/${segments.join("/")}`;
+}
+function isIndexRoute(route) {
+  return !route.isRoot && route.fullPath.endsWith("/");
+}
+function isPathlessRoute(route) {
+  return !route.isRoot && !isIndexRoute(route) && route.parent !== undefined && route.to === route.parent.to;
+}
+function parseSearchValue(value) {
+  if (value === "") {
+    return "";
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function defaultParseSearch(searchStr) {
+  const result = {};
+  const params = new URLSearchParams(searchStr.startsWith("?") ? searchStr.slice(1) : searchStr);
+  for (const [key, value] of params.entries()) {
+    result[key] = parseSearchValue(value);
+  }
+  return result;
+}
+function defaultStringifySearch(search) {
+  const params = new URLSearchParams;
+  for (const [key, value] of Object.entries(search)) {
+    if (value === undefined) {
+      continue;
+    }
+    params.set(key, typeof value === "string" ? value : JSON.stringify(value));
+  }
+  const serialized = params.toString();
+  return serialized ? `?${serialized}` : "";
+}
+function normalizePattern(pattern) {
+  if (pattern === "/") {
+    return [];
+  }
+  return pattern.split("/").filter(Boolean);
+}
+function buildPath(to, params = {}) {
+  const normalized = normalizeRouteIdRuntime(to);
+  if (normalized === "/") {
+    return "/";
+  }
+  const segments = normalized.split("/").filter(Boolean).map((segment) => {
+    if (segment === "$") {
+      return encodeURIComponent(params._splat ?? "");
+    }
+    if (segment.startsWith("$")) {
+      const key = segment.slice(1);
+      const value = params[key];
+      if (value === undefined) {
+        throw new Error(`Missing route param "${key}" for path "${to}"`);
+      }
+      return encodeURIComponent(value);
+    }
+    return segment;
+  });
+  return `/${segments.join("/")}`;
+}
+function matchPathname(pattern, pathname, options) {
+  const patternSegments = normalizePattern(normalizeRouteIdRuntime(pattern));
+  const pathnameSegments = normalizePattern(pathname);
+  const params = {};
+  if (patternSegments.length === 0) {
+    if (!options?.partial && pathnameSegments.length > 0) {
+      return null;
+    }
+    return { params };
+  }
+  let pathnameIndex = 0;
+  for (let patternIndex = 0;patternIndex < patternSegments.length; patternIndex += 1) {
+    const segment = patternSegments[patternIndex];
+    if (segment === undefined) {
+      return null;
+    }
+    if (segment === "$") {
+      params._splat = decodeURIComponent(pathnameSegments.slice(pathnameIndex).join("/"));
+      pathnameIndex = pathnameSegments.length;
+      break;
+    }
+    const current = pathnameSegments[pathnameIndex];
+    if (current === undefined) {
+      return null;
+    }
+    if (segment.startsWith("$")) {
+      params[segment.slice(1)] = decodeURIComponent(current);
+      pathnameIndex += 1;
+      continue;
+    }
+    if (segment !== current) {
+      return null;
+    }
+    pathnameIndex += 1;
+  }
+  if (!options?.partial && pathnameIndex < pathnameSegments.length) {
+    return null;
+  }
+  return { params };
+}
+function scorePattern(pattern) {
+  return normalizePattern(pattern).reduce((score, segment) => {
+    if (segment === "$") {
+      return score + 1;
+    }
+    if (segment.startsWith("$")) {
+      return score + 2;
+    }
+    return score + 3;
+  }, 0);
+}
+function canTerminate(route) {
+  if (route.isRoot || isPathlessRoute(route)) {
+    return false;
+  }
+  if (route.children.length === 0) {
+    return true;
+  }
+  return !route.children.some((child) => isIndexRoute(child));
+}
+function collectBranches(routeTree) {
+  const branches = [];
+  function walk(route, ancestors) {
+    const nextAncestors = [...ancestors, route];
+    if (canTerminate(route)) {
+      branches.push({
+        leaf: route,
+        routes: nextAncestors,
+        score: scorePattern(route.to) + nextAncestors.length
+      });
+    }
+    for (const child of route.children) {
+      walk(child, nextAncestors);
+    }
+  }
+  walk(routeTree, []);
+  return branches.sort((left, right) => right.score - left.score);
+}
+function collectRoutes(routeTree) {
+  const routes = [];
+  function walk(route) {
+    routes.push(route);
+    for (const child of route.children) {
+      walk(child);
+    }
+  }
+  walk(routeTree);
+  return routes;
+}
+function matchRouteTree(routeTree, pathname) {
+  const branches = collectBranches(routeTree);
+  for (const branch of branches) {
+    const leafMatch = matchPathname(branch.leaf.to, pathname);
+    if (!leafMatch) {
+      continue;
+    }
+    const matched = branch.routes.map((route) => {
+      const partialMatch = matchPathname(route.to, pathname, {
+        partial: route !== branch.leaf
+      });
+      return {
+        route,
+        params: partialMatch?.params ?? {}
+      };
+    });
+    return matched;
+  }
+  return null;
+}
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function renderAttributes(attributes) {
+  return Object.entries(attributes).flatMap(([key, value]) => {
+    if (value === undefined || value === false) {
+      return [];
+    }
+    if (value === true) {
+      return [key];
+    }
+    return [`${key}="${escapeHtml(value)}"`];
+  }).join(" ");
+}
+function mergeHeadConfigs(heads) {
+  const titles = [];
+  const metaByKey = new Map;
+  const linksByKey = new Map;
+  const styles = [];
+  const scripts = [];
+  for (const head of heads) {
+    for (const meta of head.meta ?? []) {
+      if ("title" in meta) {
+        titles.push(meta);
+        continue;
+      }
+      if ("charset" in meta) {
+        metaByKey.set("charset", meta);
+        continue;
+      }
+      if ("name" in meta) {
+        metaByKey.set(`name:${meta.name}`, meta);
+        continue;
+      }
+      if ("property" in meta) {
+        metaByKey.set(`property:${meta.property}`, meta);
+        continue;
+      }
+      metaByKey.set(`httpEquiv:${meta.httpEquiv}`, meta);
+    }
+    for (const link of head.links ?? []) {
+      linksByKey.set(`${link.rel}:${link.href}`, link);
+    }
+    styles.push(...head.styles ?? []);
+    scripts.push(...head.scripts ?? []);
+  }
+  const title = titles.at(-1);
+  return {
+    meta: [...title ? [title] : [], ...metaByKey.values()],
+    links: [...linksByKey.values()],
+    styles,
+    scripts
+  };
+}
+function resolveInlineHead(match, matches) {
+  const headOption = match.route.options.head;
+  if (!headOption || typeof headOption === "string") {
+    return null;
+  }
+  return typeof headOption === "function" ? headOption({
+    params: match.params,
+    search: match.search,
+    matches
+  }) : headOption;
+}
+function resolveHeadConfig(matches, resolvedHeadByRoute) {
+  const heads = [];
+  for (const match of matches) {
+    const resolvedHead = resolvedHeadByRoute?.get(match.route.fullPath);
+    if (resolvedHead) {
+      heads.push(resolvedHead);
+    }
+    const inlineHead = resolveInlineHead(match, matches);
+    if (inlineHead) {
+      heads.push(inlineHead);
+    }
+  }
+  return mergeHeadConfigs(heads);
+}
+function serializeHeadConfig(head, options) {
+  const managedAttributes = options?.managedAttribute ? {
+    [options.managedAttribute]: "true"
+  } : {};
+  const meta = (head.meta ?? []).map((tag) => {
+    if ("title" in tag) {
+      return `<title ${renderAttributes(managedAttributes)}>${escapeHtml(tag.title)}</title>`;
+    }
+    if ("charset" in tag) {
+      return `<meta ${renderAttributes({ charset: tag.charset, ...managedAttributes })}>`;
+    }
+    if ("name" in tag) {
+      return `<meta ${renderAttributes({ name: tag.name, content: tag.content, ...managedAttributes })}>`;
+    }
+    if ("property" in tag) {
+      return `<meta ${renderAttributes({ property: tag.property, content: tag.content, ...managedAttributes })}>`;
+    }
+    return `<meta ${renderAttributes({ "http-equiv": tag.httpEquiv, content: tag.content, ...managedAttributes })}>`;
+  });
+  const links = (head.links ?? []).map((link) => `<link ${renderAttributes({
+    rel: link.rel,
+    href: link.href,
+    type: link.type,
+    media: link.media,
+    sizes: link.sizes,
+    crossorigin: link.crossorigin,
+    ...managedAttributes
+  })}>`);
+  const styles = (head.styles ?? []).map((style) => {
+    const attributes = renderAttributes({ media: style.media, ...managedAttributes });
+    return `<style${attributes ? ` ${attributes}` : ""}>${style.children}</style>`;
+  });
+  const scripts = (head.scripts ?? []).map((script) => {
+    const attributes = renderAttributes({
+      src: script.src,
+      type: script.type,
+      async: script.async,
+      defer: script.defer,
+      ...managedAttributes
+    });
+    return `<script${attributes ? ` ${attributes}` : ""}>${script.children ?? ""}</script>`;
+  });
+  return [...meta, ...links, ...styles, ...scripts].join("");
+}
+function createParsedLocation(href, state, parseSearch) {
+  const base = href.startsWith("http://") || href.startsWith("https://") ? href : `http://richie-router.local${href}`;
+  const url = new URL(base);
+  return {
+    pathname: url.pathname,
+    search: parseSearch(url.search),
+    searchStr: url.search,
+    hash: url.hash,
+    href: `${url.pathname}${url.search}${url.hash}`,
+    state
+  };
+}
+export {
+  serializeHeadConfig,
+  resolveHeadConfig,
+  redirect,
+  parseSearchValue,
+  notFound,
+  normalizeRouteIdRuntime,
+  mergeHeadConfigs,
+  matchRouteTree,
+  matchPathname,
+  isRedirect,
+  isPathlessRoute,
+  isNotFound,
+  isIndexRoute,
+  defineHeadTagSchema,
+  defaultStringifySearch,
+  defaultParseSearch,
+  createRouteNode,
+  createParsedLocation,
+  collectRoutes,
+  collectBranches,
+  buildPath,
+  RouteNode,
+  RedirectError,
+  NotFoundError
+};

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/types/index.d.ts

@@ -0,0 +1,199 @@
+export type AnyComponent = (props?: any) => unknown;
+export interface SchemaLike<TOutput = unknown> {
+    parse(value: unknown): TOutput;
+}
+export interface HeadTagSchemaEntry<TSearchSchema extends SchemaLike<any> | undefined = SchemaLike<any> | undefined> {
+    searchSchema?: TSearchSchema;
+}
+export type HeadTagSchemaShape = Record<string, HeadTagSchemaEntry>;
+export declare function defineHeadTagSchema<const TSchema extends HeadTagSchemaShape>(schema: TSchema): TSchema;
+type SchemaOutput<TSchema> = TSchema extends {
+    _output: infer TOutput;
+} ? TOutput : TSchema extends SchemaLike<infer TOutput> ? TOutput : never;
+export type InferHeadTagSearchSchema<TSchema extends HeadTagSchemaShape, THeadTagName extends keyof TSchema> = TSchema[THeadTagName] extends {
+    searchSchema: infer TSearchSchema;
+} ? SchemaOutput<TSearchSchema> : {};
+export type Simplify<TValue> = {
+    [TKey in keyof TValue]: TValue[TKey];
+} & {};
+type NormalizePathInternal<TValue extends string> = TValue extends `/${infer TRest}` ? NormalizePathSegments<TRest> extends infer TSegments extends string ? TSegments extends '' ? '/' : `/${TSegments}` : never : TValue;
+type NormalizePathSegments<TValue extends string> = TValue extends `${infer THead}/${infer TTail}` ? JoinNormalizedSegments<NormalizePathSegment<THead>, NormalizePathSegments<TTail>> : NormalizePathSegment<TValue>;
+type JoinNormalizedSegments<TLeft extends string, TRight extends string> = TLeft extends '' ? TRight : TRight extends '' ? TLeft : `${TLeft}/${TRight}`;
+type NormalizePathSegment<TSegment extends string> = TSegment extends '' ? '' : TSegment extends `_${string}` ? '' : TSegment extends `${infer TBase}_` ? TBase : TSegment;
+export type NormalizeRouteId<TValue extends string> = TValue extends '__root__' ? '/' : TValue extends '/' ? '/' : TValue extends `${infer TPrefix}/` ? TPrefix extends '' ? '/' : NormalizePathInternal<TPrefix> : NormalizePathInternal<TValue>;
+type ParsePathParamsInternal<TValue extends string> = TValue extends `${infer _Start}/$/${infer TRest}` ? '_splat' | ParsePathParamsInternal<`/${TRest}`> : TValue extends `${infer _Start}/$` ? '_splat' : TValue extends `${infer _Start}/$${infer TParam}/${infer TRest}` ? TParam | ParsePathParamsInternal<`/${TRest}`> : TValue extends `${infer _Start}/$${infer TParam}` ? TParam : never;
+export type ParsePathParams<TPath extends string> = ParsePathParamsInternal<NormalizeRouteId<TPath>>;
+export type ResolveAllParams<TPath extends string> = Simplify<{
+    [TKey in ParsePathParams<TPath>]: string;
+}>;
+export interface HeadTagTitle {
+    title: string;
+}
+export interface HeadTagName {
+    name: string;
+    content: string;
+}
+export interface HeadTagProperty {
+    property: string;
+    content: string;
+}
+export interface HeadTagHttpEquiv {
+    httpEquiv: string;
+    content: string;
+}
+export interface HeadTagCharset {
+    charset: string;
+}
+export type HeadTag = HeadTagTitle | HeadTagName | HeadTagProperty | HeadTagHttpEquiv | HeadTagCharset;
+export interface HeadLinkTag {
+    rel: string;
+    href: string;
+    type?: string;
+    media?: string;
+    sizes?: string;
+    crossorigin?: string;
+}
+export interface HeadStyleTag {
+    children: string;
+    media?: string;
+}
+export interface HeadScriptTag {
+    src?: string;
+    children?: string;
+    type?: string;
+    async?: boolean;
+    defer?: boolean;
+}
+export interface HeadConfig {
+    meta?: HeadTag[];
+    links?: HeadLinkTag[];
+    styles?: HeadStyleTag[];
+    scripts?: HeadScriptTag[];
+}
+export interface DehydratedHeadState {
+    href: string;
+    head: HeadConfig;
+}
+export interface ParsedLocation<TSearch = Record<string, unknown>> {
+    pathname: string;
+    search: TSearch;
+    searchStr: string;
+    hash: string;
+    href: string;
+    state: unknown;
+}
+export interface RedirectTarget {
+    to: string;
+    params?: Record<string, string>;
+    search?: Record<string, unknown> | true;
+    hash?: string;
+    replace?: boolean;
+    state?: Record<string, unknown>;
+}
+export declare class RedirectError extends Error {
+    readonly options: RedirectTarget;
+    constructor(options: RedirectTarget);
+}
+export declare class NotFoundError extends Error {
+    constructor(message?: string);
+}
+export declare function redirect(options: RedirectTarget): never;
+export declare function notFound(message?: string): never;
+export declare function isRedirect(error: unknown): error is RedirectError;
+export declare function isNotFound(error: unknown): error is NotFoundError;
+export interface RouteMatch<TRoute extends AnyRoute = AnyRoute> {
+    id: string;
+    pathname: string;
+    params: Record<string, string>;
+    route: TRoute;
+    search: unknown;
+    to: string;
+}
+export interface RouteOptions<TPath extends string = string, TSearch = unknown> {
+    component?: AnyComponent;
+    pendingComponent?: AnyComponent;
+    errorComponent?: AnyComponent;
+    notFoundComponent?: AnyComponent;
+    head?: string | HeadConfig | ((ctx: {
+        params: ResolveAllParams<TPath>;
+        search: TSearch;
+        matches: RouteMatch[];
+    }) => HeadConfig);
+    validateSearch?: (raw: Record<string, unknown>) => TSearch;
+    beforeLoad?: (ctx: {
+        location: ParsedLocation;
+        params: ResolveAllParams<TPath>;
+        search: TSearch;
+        navigate: (options: RedirectTarget) => Promise<void>;
+        cause: 'enter' | 'stay';
+    }) => void | Promise<void>;
+    pendingMs?: number;
+    pendingMinMs?: number;
+    staticData?: Record<string, unknown>;
+}
+export interface RouteTypeInfo<TId extends string = string, TTo extends string = string, TParams extends Record<string, string> = Record<string, string>, TSearch = unknown> {
+    id: TId;
+    fullPath: TId;
+    to: TTo;
+    params: TParams;
+    search: TSearch;
+}
+export declare class RouteNode<TId extends string = string, TTo extends string = string, TParams extends Record<string, string> = Record<string, string>, TSearch = unknown, TFileTypes = unknown> {
+    id: TId;
+    fullPath: TId;
+    to: TTo;
+    parent?: AnyRoute;
+    children: AnyRoute[];
+    searchSchema?: SchemaLike<TSearch>;
+    routeTypes?: TFileTypes;
+    readonly isRoot: boolean;
+    readonly options: RouteOptions<TId, TSearch>;
+    types: RouteTypeInfo<TId, TTo, TParams, TSearch>;
+    __fileTypes: TFileTypes;
+    constructor(path: TId, options: RouteOptions<TId, TSearch>, init?: {
+        isRoot?: boolean;
+    });
+    update(config: {
+        id: TId;
+        path: TId;
+        getParentRoute?: () => AnyRoute;
+    }): this;
+    _addFileChildren<TChildren extends Record<string, AnyRoute>>(children: TChildren): this;
+    _addFileTypes<TNextFileTypes>(): RouteNode<TId, TTo, TParams, TSearch, TNextFileTypes>;
+    _setSearchSchema<TSchema extends SchemaLike<TSearch>>(schema: TSchema): this;
+}
+export type AnyRoute = RouteNode<any, any, any, any, any>;
+export declare function createRouteNode<TId extends string, TTo extends string, TParams extends Record<string, string>, TSearch>(path: TId, options: RouteOptions<TId, TSearch>, init?: {
+    isRoot?: boolean;
+}): RouteNode<TId, TTo, TParams, TSearch>;
+export declare function normalizeRouteIdRuntime(routeId: string): string;
+export declare function isIndexRoute(route: AnyRoute): boolean;
+export declare function isPathlessRoute(route: AnyRoute): boolean;
+export declare function parseSearchValue(value: string): unknown;
+export declare function defaultParseSearch(searchStr: string): Record<string, unknown>;
+export declare function defaultStringifySearch(search: Record<string, unknown>): string;
+export declare function buildPath(to: string, params?: Record<string, string>): string;
+export declare function matchPathname(pattern: string, pathname: string, options?: {
+    partial?: boolean;
+}): {
+    params: Record<string, string>;
+} | null;
+export interface RouteBranch {
+    leaf: AnyRoute;
+    routes: AnyRoute[];
+    score: number;
+}
+export declare function collectBranches(routeTree: AnyRoute): RouteBranch[];
+export declare function collectRoutes(routeTree: AnyRoute): AnyRoute[];
+export interface MatchedRoute {
+    route: AnyRoute;
+    params: Record<string, string>;
+}
+export declare function matchRouteTree(routeTree: AnyRoute, pathname: string): MatchedRoute[] | null;
+export declare function mergeHeadConfigs(heads: HeadConfig[]): HeadConfig;
+export declare function resolveHeadConfig(matches: RouteMatch[], resolvedHeadByRoute?: Map<string, HeadConfig>): HeadConfig;
+export declare function serializeHeadConfig(head: HeadConfig, options?: {
+    managedAttribute?: string;
+}): string;
+export declare function createParsedLocation<TSearch>(href: string, state: unknown, parseSearch: (searchStr: string) => TSearch): ParsedLocation<TSearch>;
+export {};

package/package.json

@@ -1,10 +1,43 @@
 {
   "name": "@richie-router/core",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @richie-router/core",
+  "version": "0.1.1",
+  "description": "Shared route, search, and head utilities for Richie Router",
+  "sideEffects": false,
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.cjs",
+      "default": "./dist/esm/index.mjs"
+    }
+  },
+  "author": "Richie <oss@ricsam.dev>",
+  "homepage": "https://docs.ricsam.dev/richie-router",
+  "bugs": {
+    "url": "https://github.com/ricsam/richie-router/issues"
+  },
   "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
-}
+    "router",
+    "react",
+    "typescript",
+    "bun",
+    "file-based-routing",
+    "type-safe"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ricsam/richie-router.git",
+    "directory": "packages/core"
+  },
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/esm/index.mjs",
+  "types": "./dist/types/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}

package/README.md

@@ -1,45 +0,0 @@
-# @richie-router/core
-
-## ⚠️ IMPORTANT NOTICE ⚠️
-
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
-
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
-
-## Purpose
-
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@richie-router/core`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
-
-## What is OIDC Trusted Publishing?
-
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
-
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
-
-## DO NOT USE THIS PACKAGE
-
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
-
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**