@jant/core 0.6.16 → 0.7.1

package/src/lib/url.ts

@@ -2,16 +2,6 @@
  * URL Utilities
  */
 
-import limax from "limax";
-
-import {
-  HAN_RE,
-  HANGUL_RE,
-  KANA_RE,
-  hangulToLatin,
-  kanaToRomaji,
-} from "./translit.js";
-
 function normalizeSitePathname(pathname: string): string {
   if (pathname === "/" || pathname === "") return "";
   const trimmed = pathname.replace(/\/+$/, "");
@@ -141,97 +131,160 @@ export function toSameSitePath(url: string, siteOrigin: string): string | null {
   return `${parsed.pathname}${parsed.search}${parsed.hash}` || "/";
 }
 
-const HAN_GLOBAL_RE = /\p{Script=Han}/gu;
-const CONTENT_CHAR_RE = /[\p{L}\p{N}]/u;
-const ASCII_ALNUM_RE = /[a-zA-Z0-9]/;
-
 /**
- * Minimum fraction of a title's letters/digits the transliteration pipeline
- * must handle for the result to be usable. Below this, too much meaning is
- * lost (e.g. mixed kanji+kana Japanese where the semantic core is kanji, or
- * scripts limax drops entirely) and `slugify` returns "" so callers fall back
- * to their random-ID path instead of shipping a garbled slug.
+ * Any `scheme:` at the start. `mailto:` and `tel:` address something real but
+ * never a page here, and an unrecognized scheme must not be read as a path.
  */
-const SLUG_COVERAGE_THRESHOLD = 0.75;
-
-/** Per-character limax probe cache: does this char transliterate to anything? */
-const charCoverageCache = new Map<string, boolean>();
-
-function isCharCovered(char: string): boolean {
-  if (ASCII_ALNUM_RE.test(char)) return true;
-  let covered = charCoverageCache.get(char);
-  if (covered === undefined) {
-    covered = limax(char, { tone: false }).length > 0;
-    charCoverageCache.set(char, covered);
-  }
-  return covered;
-}
-
-function slugCoverage(text: string, japanese: boolean): number {
-  let content = 0;
-  let covered = 0;
-  for (const char of text) {
-    if (!CONTENT_CHAR_RE.test(char)) continue;
-    content++;
-    if (KANA_RE.test(char) || HANGUL_RE.test(char)) {
-      covered++;
-    } else if (japanese && HAN_RE.test(char)) {
-      // Kanji in a kana-containing title is dropped, never pinyin-read.
-    } else if (isCharCovered(char)) {
-      covered++;
-    }
-  }
-  return content === 0 ? 0 : covered / content;
+const ANY_SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
+
+export interface InternalPathOptions {
+  /**
+   * Origins this site answers on. Pass the configured one *and* the origin of
+   * the current request: a hosted site is often reached on a custom domain the
+   * canonical URL knows nothing about.
+   */
+  siteOrigins?: readonly string[];
+  /** Public site path prefix, such as `/blog`. */
+  sitePathPrefix?: string;
+  /**
+   * Language URL prefixes the site serves, without slashes (`["en", "ja"]`).
+   * A leading one is removed, because `/en/about` and `/about` are the same
+   * page seen from two views.
+   */
+  languagePrefixes?: readonly string[];
+  /** Keep `?query` and `#hash`. Off by default: they name a spot, not a page. */
+  keepQuery?: boolean;
 }
 
 /**
- * Converts text to a URL-friendly slug.
- *
- * Transliterates i18n text to Latin before slugifying: Korean hangul via
- * Revised Romanization, Japanese kana via Hepburn romaji (both in-house, see
- * `translit.ts`), everything else (Han → pinyin, Cyrillic, accents, …) via
- * limax. When the title contains kana it is treated as Japanese and Han
- * characters are dropped rather than misread as Chinese pinyin; Han without
- * kana is treated as Chinese.
+ * Whether a string is meant as an address rather than as search words.
  *
- * Returns `""` when transliteration would lose too much of the title (see
- * `SLUG_COVERAGE_THRESHOLD`) — every caller treats an empty base as "no
- * usable title" and falls back to a random ID, which beats publishing a
- * garbled slug.
- *
- * @param text - The text to convert to a slug
- * @returns The slugified string, or `""` when no usable slug can be derived
+ * Deliberately narrow — a leading slash or a full `http(s)` URL. Anything
+ * looser would swallow real queries: a search for "about" is not a search for
+ * `/about`.
  *
+ * @param input - What the author typed or pasted
+ * @returns True when the input should be resolved instead of searched
  * @example
- * ```ts
- * slugify("Hello World! This is a Test.");
- * // Returns: "hello-world-this-is-a-test"
+ * looksLikeAddress("/about"); // true
+ * looksLikeAddress("https://example.com/about"); // true
+ * looksLikeAddress("about"); // false
+ */
+export function looksLikeAddress(input: string): boolean {
+  const trimmed = input.trim();
+  return trimmed.startsWith("/") || isFullUrl(trimmed);
+}
+
+/**
+ * Convert an address the author pasted into an internal app path.
  *
- * slugify("书评");
- * // Returns: "shu-ping"
+ * Accepts what a browser address bar would produce — a full URL on one of the
+ * site's own origins, or a path — and returns the path the router resolves
+ * against: no site path prefix, no language prefix, rooted at `/`. Returns
+ * `null` for anything that is not a page on this site, so callers can tell an
+ * external link apart from a bad one.
  *
- * slugify("안녕하세요 세계");
- * // Returns: "annyeonghaseyo-segye"
+ * Case is left alone; storage-level normalization belongs to the path
+ * registry, which lowercases on its own terms.
  *
- * slugify("ハンバーガー");
- * // Returns: "hanbaga"
+ * A full URL has to sit inside the deployment to count. A typed path does not:
+ * `/about` on a site served from `/blog` is the About page, because that is
+ * what someone typing it means.
  *
- * slugify("日本語のタイトルです");
- * // Returns: "" (kanji carries the meaning and can't be transliterated)
- * ```
+ * @param input - A full URL, or a path
+ * @param options - The site's origins, prefixes, and what to keep
+ * @returns Internal path rooted at `/`, or `null` when the address is not ours
+ * @example
+ * toInternalPath("https://example.com/blog/en/about", {
+ *   siteOrigins: ["https://example.com"],
+ *   sitePathPrefix: "/blog",
+ *   languagePrefixes: ["en"],
+ * }); // "/about"
+ * toInternalPath("https://other.com/about", { siteOrigins: ["https://example.com"] }); // null
  */
-export function slugify(text: string): string {
-  const japanese = KANA_RE.test(text);
-  let pre = text;
-  if (japanese) {
-    pre = kanaToRomaji(pre.replace(HAN_GLOBAL_RE, " "));
+export function toInternalPath(
+  input: string,
+  options: InternalPathOptions = {},
+): string | null {
+  const value = input.trim();
+  if (!value) return null;
+
+  const {
+    siteOrigins = [],
+    sitePathPrefix = "",
+    languagePrefixes = [],
+    keepQuery = false,
+  } = options;
+
+  const isFull = isFullUrl(value);
+  let candidate: string | null = null;
+  if (isFull) {
+    for (const origin of siteOrigins) {
+      const path = toSameSitePath(value, origin);
+      if (path !== null) {
+        candidate = path;
+        break;
+      }
+    }
+    // A full URL on a host we do not serve is somebody else's page.
+    if (candidate === null) return null;
+  } else if (
+    value.startsWith("//") ||
+    ANY_SCHEME_RE.test(value) ||
+    value.startsWith("#")
+  ) {
+    return null;
+  } else {
+    candidate = value;
+  }
+
+  let url: URL;
+  try {
+    // A fixed base resolves `..`, percent-encoding, and stray backslashes the
+    // same way the browser that produced the address did.
+    url = new URL(candidate, "https://jant.invalid");
+  } catch {
+    return null;
   }
-  if (HANGUL_RE.test(pre)) {
-    pre = hangulToLatin(pre);
+
+  const withoutSite = stripSitePathPrefix(
+    url.pathname,
+    normalizeSitePathPrefix(sitePathPrefix),
+  );
+  if (withoutSite === null && isFull) {
+    // A URL on our host but outside the deployment: another app, not a page.
+    return null;
+  }
+
+  // A typed path that does not carry the prefix is already an internal one —
+  // an author writing `/about` on a site served from `/blog` means the About
+  // page, not a different site.
+  const internal = stripLanguagePrefix(
+    withoutSite ?? url.pathname,
+    languagePrefixes,
+  );
+  const trimmed =
+    internal.length > 1 ? internal.replace(/\/+$/, "") || "/" : internal;
+
+  return keepQuery ? `${trimmed}${url.search}${url.hash}` : trimmed;
+}
+
+/** Drop a leading `/en`-style segment when the site serves that language. */
+function stripLanguagePrefix(
+  pathname: string,
+  languagePrefixes: readonly string[],
+): string {
+  if (languagePrefixes.length === 0) return pathname;
+
+  const rest = pathname.startsWith("/") ? pathname.slice(1) : pathname;
+  const slash = rest.indexOf("/");
+  const first = (slash === -1 ? rest : rest.slice(0, slash)).toLowerCase();
+  if (!first) return pathname;
+  if (!languagePrefixes.some((prefix) => prefix.toLowerCase() === first)) {
+    return pathname;
   }
-  const base = limax(pre, { tone: false }).replace(/_/g, "-");
-  if (!base) return "";
-  return slugCoverage(text, japanese) >= SLUG_COVERAGE_THRESHOLD ? base : "";
+
+  return slash === -1 ? "/" : rest.slice(slash);
 }
 
 /**
@@ -433,6 +486,26 @@ export function toPublicPath(path: string, sitePathPrefix = ""): string {
   return `${sitePathPrefix}${normalizedPath}`;
 }
 
+/**
+ * The internal path a Post is served at: its oldest custom path when it has
+ * one, else its slug.
+ *
+ * This is the Post's permalink before the site path prefix, and so the `<id>`
+ * of its Atom entry. The Hugo export writes that `<id>` into front matter so
+ * an exported feed keeps it, which is why the rule lives here rather than
+ * inside `toPostView`.
+ *
+ * @param slug - The Post's current slug
+ * @param aliasPath - Its oldest custom path, `paths.getPostAliases()`'s first
+ * @returns Internal path rooted at `/`
+ * @example
+ * getPostPath("xta29"); // "/xta29"
+ * getPostPath("links-4", "/blog/links/4"); // "/blog/links/4"
+ */
+export function getPostPath(slug: string, aliasPath?: string): string {
+  return aliasPath ?? `/${slug}`;
+}
+
 /**
  * Convert an app-local href to its public path while leaving external URLs
  * unchanged.

package/src/lib/version.ts

@@ -1,33 +1,35 @@
 /**
- * Version and environment detection
- *
- * In Vite dev, `__JANT_DEV__` is replaced with `true` via Vite's `define` config.
- * In production (wrangler/esbuild), the typeof check evaluates to false safely.
+ * Version and build asset paths
  *
  * `__JANT_VERSION__` is replaced by Vite's `define` during both dev and lib build.
  *
  * `__CLIENT_JS_FILE__` and `__CLIENT_AUTH_JS_FILE__` are content-addressed
  * internal paths (e.g. `/_assets/client-HASH.js`) embedded by the Worker build
  * from the Vite client manifest. Used only in production (IS_VITE_DEV=false).
+ * `__CLIENT_COMPOSE_PRELOAD__` lists every file the composer entry needs —
+ * the entry and the chunks it imports — for the layout's modulepreload links.
+ *
+ * The dev flag itself lives in `build-env.ts`, which client bundles can import
+ * without these Worker-only globals.
  */
 
-declare const __JANT_DEV__: boolean | undefined;
 declare const __JANT_VERSION__: string;
 declare const __CLIENT_JS_FILE__: string;
 declare const __CLIENT_AUTH_JS_FILE__: string;
+declare const __CLIENT_COMPOSE_PRELOAD__: readonly string[];
 declare const __CLIENT_CSS_FILE__: string;
+declare const __CLIENT_AUTHOR_CSS_FILE__: string;
 declare const __CLIENT_CJK_CSS_FILE__: string;
 declare const __CLIENT_CJK_TC_CSS_FILE__: string;
 declare const __CLIENT_CJK_JP_CSS_FILE__: string;
 declare const __CLIENT_CJK_KR_CSS_FILE__: string;
 
-export const IS_VITE_DEV =
-  typeof __JANT_DEV__ !== "undefined" && __JANT_DEV__ === true;
-
 export const CORE_VERSION = __JANT_VERSION__;
 export const CLIENT_JS_FILE = __CLIENT_JS_FILE__;
 export const CLIENT_AUTH_JS_FILE = __CLIENT_AUTH_JS_FILE__;
+export const CLIENT_COMPOSE_PRELOAD = __CLIENT_COMPOSE_PRELOAD__;
 export const CLIENT_CSS_FILE = __CLIENT_CSS_FILE__;
+export const CLIENT_AUTHOR_CSS_FILE = __CLIENT_AUTHOR_CSS_FILE__;
 export const CLIENT_CJK_CSS_FILE = __CLIENT_CJK_CSS_FILE__;
 export const CLIENT_CJK_TC_CSS_FILE = __CLIENT_CJK_TC_CSS_FILE__;
 export const CLIENT_CJK_JP_CSS_FILE = __CLIENT_CJK_JP_CSS_FILE__;