@jant/core 0.6.15 → 0.7.0

package/dist/url-BMYO-Zlt.js

@@ -1,395 +0,0 @@
-import limax from "limax";
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-//#endregion
-//#region src/lib/url.ts
-/**
-* URL Utilities
-*/ var url_exports = /* @__PURE__ */ __exportAll({
-	buildSiteUrl: () => buildSiteUrl,
-	extractDisplayDomain: () => extractDisplayDomain,
-	extractDomain: () => extractDomain,
-	getSiteOrigin: () => getSiteOrigin,
-	getSitePathPrefix: () => getSitePathPrefix,
-	isFullUrl: () => isFullUrl,
-	isSafeAbsoluteUrl: () => isSafeAbsoluteUrl,
-	isSafeInternalRedirect: () => isSafeInternalRedirect,
-	normalizePath: () => normalizePath,
-	normalizeSitePathPrefix: () => normalizeSitePathPrefix,
-	normalizeSiteUrl: () => normalizeSiteUrl,
-	sanitizeUrl: () => sanitizeUrl,
-	slugify: () => slugify,
-	stripSitePathPrefix: () => stripSitePathPrefix,
-	toAbsoluteAssetUrl: () => toAbsoluteAssetUrl,
-	toAbsoluteSiteUrl: () => toAbsoluteSiteUrl,
-	toPublicHref: () => toPublicHref,
-	toPublicPath: () => toPublicPath,
-	toSameSitePath: () => toSameSitePath
-});
-function normalizeSitePathname(pathname) {
-	if (pathname === "/" || pathname === "") return "";
-	const trimmed = pathname.replace(/\/+$/, "");
-	return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
-}
-/**
-* Normalize a configured public site path prefix.
-*
-* @param sitePathPrefix - Prefix such as `/blog` or `blog`
-* @returns Normalized prefix like `/blog`, or an empty string when rooted
-*/ function normalizeSitePathPrefix(sitePathPrefix) {
-	return normalizeSitePathname(sitePathPrefix);
-}
-/**
-* Extracts the hostname (domain) from a URL string.
-*
-* Parses a full URL and returns just the hostname portion (e.g., "example.com" from
-* "https://example.com/path"). Returns `null` if the URL is malformed or cannot be parsed.
-*
-* @param url - The full URL string to extract the domain from
-* @returns The hostname/domain if valid, or `null` if parsing fails
-*
-* @example
-* ```ts
-* const domain = extractDomain("https://www.example.com/path");
-* // Returns: "www.example.com"
-*
-* const invalid = extractDomain("not-a-url");
-* // Returns: null
-* ```
-*/ function extractDomain(url) {
-	try {
-		return new URL(url).hostname;
-	} catch {
-		return null;
-	}
-}
-/**
-* Normalizes a path by removing slashes and converting to lowercase.
-*
-* Trims whitespace, converts to lowercase, removes leading and trailing slashes,
-* and collapses multiple consecutive slashes into single slashes. Used to create
-* consistent path representations for routing and storage.
-*
-* @param path - The path string to normalize
-* @returns The normalized path string
-*
-* @example
-* ```ts
-* const normalized = normalizePath("  /About/Contact//  ");
-* // Returns: "about/contact"
-* ```
-*/ function normalizePath(path) {
-	return path.trim().toLowerCase().replace(/^\/+|\/+$/g, "").replace(/\/+/g, "/");
-}
-/**
-* Checks if a string is a full URL with HTTP or HTTPS protocol.
-*
-* Validates whether a string starts with "http://" or "https://", indicating it's
-* a full URL rather than a relative path. Useful for distinguishing between internal
-* paths and external URLs.
-*
-* @param str - The string to check
-* @returns `true` if the string starts with http:// or https://, `false` otherwise
-*
-* @example
-* ```ts
-* isFullUrl("https://example.com");  // Returns: true
-* isFullUrl("/about");               // Returns: false
-* isFullUrl("example.com");          // Returns: false
-* ```
-*/ function isFullUrl(str) {
-	return str.startsWith("http://") || str.startsWith("https://");
-}
-/**
-* If a full URL points at the site's own host, return its same-site path
-* (`pathname` + `search` + `hash`). Returns `null` when the input is not a full
-* URL, is unparseable, or points at a different host.
-*
-* Self-referential absolute links — e.g. a nav item set to
-* `https://example.com/about` on `example.com` — should behave like the
-* internal path `/about`: no external-link icon, no `target="_blank"`.
-*
-* Matching is by **hostname**, not full origin: scheme and port differences are
-* treated as same-site. This keeps the check intuitive ("same domain") and
-* robust in dev, where the site is often served over `http://host:<port>` while
-* a nav link stores the canonical `https://host` URL. In production (canonical
-* https + default port) hostname match is equivalent to origin match.
-*
-* @param url - Candidate URL (full URL or relative path)
-* @param siteOrigin - The site's own origin, e.g. `https://example.com`
-* @returns The same-site path, or `null` when the URL is external/non-absolute
-*
-* @example
-* ```ts
-* toSameSitePath("https://example.com/about", "https://example.com");    // "/about"
-* toSameSitePath("https://example.com/about", "http://example.com:8787"); // "/about"
-* toSameSitePath("https://other.com/about", "https://example.com");      // null
-* toSameSitePath("/about", "https://example.com");                       // null
-* ```
-*/ function toSameSitePath(url, siteOrigin) {
-	if (!siteOrigin || !isFullUrl(url)) return null;
-	let parsed;
-	let reference;
-	try {
-		parsed = new URL(url);
-		reference = new URL(siteOrigin);
-	} catch {
-		return null;
-	}
-	if (parsed.hostname !== reference.hostname) return null;
-	return `${parsed.pathname}${parsed.search}${parsed.hash}` || "/";
-}
-/**
-* Converts text to a URL-friendly slug.
-*
-* Transforms text into a lowercase, hyphen-separated slug using limax for
-* i18n-aware transliteration (CJK → Pinyin, Japanese → Romaji, accented → ASCII).
-*
-* @param text - The text to convert to a slug
-* @returns The slugified string
-*
-* @example
-* ```ts
-* slugify("Hello World! This is a Test.");
-* // Returns: "hello-world-this-is-a-test"
-*
-* slugify("书评");
-* // Returns: "shu-ping"
-* ```
-*/ function slugify(text) {
-	return limax(text, { tone: false }).replace(/_/g, "-");
-}
-/**
-* Extracts a human-friendly domain name from a URL for display purposes.
-*
-* Parses the URL, strips common prefixes (`www.`, `m.`, `mobile.`), and returns
-* a clean domain. Returns `null` if the URL is malformed.
-*
-* @param url - The full URL string
-* @returns A display-friendly domain string, or `null` if parsing fails
-*
-* @example
-* ```ts
-* extractDisplayDomain("https://www.example.com/path");
-* // Returns: "example.com"
-*
-* extractDisplayDomain("https://m.wikipedia.org/wiki/Test");
-* // Returns: "wikipedia.org"
-*
-* extractDisplayDomain("https://blog.example.com");
-* // Returns: "blog.example.com"
-* ```
-*/ function extractDisplayDomain(url) {
-	const hostname = extractDomain(url);
-	if (!hostname) return null;
-	return hostname.replace(/^(?:www|m|mobile)\./, "");
-}
-var SAFE_URL_PROTOCOLS = new Set([
-	"http:",
-	"https:",
-	"mailto:"
-]);
-/**
-* Checks whether a string is a safe absolute URL.
-*
-* Accepts absolute URLs that use `http:`, `https:`, or `mailto:`. Relative
-* paths are rejected because external post/source URLs must be fully qualified.
-*
-* @param url - The URL string to validate
-* @returns `true` when the URL is absolute and uses an allowed protocol
-*
-* @example
-* ```ts
-* isSafeAbsoluteUrl("https://example.com"); // true
-* isSafeAbsoluteUrl("mailto:hello@example.com"); // true
-* isSafeAbsoluteUrl("example.com"); // false
-* ```
-*/ function isSafeAbsoluteUrl(url) {
-	const trimmed = url.trim();
-	if (!trimmed) return false;
-	try {
-		const parsed = new URL(trimmed);
-		return SAFE_URL_PROTOCOLS.has(parsed.protocol);
-	} catch {
-		return false;
-	}
-}
-/**
-* Sanitizes a URL by ensuring it uses a safe protocol.
-*
-* Returns the URL unchanged if it uses an allowed protocol (http:, https:, mailto:)
-* or is a relative path. Returns an empty string for dangerous protocols like
-* `javascript:`, `data:`, or `vbscript:`.
-*
-* @param url - The URL string to sanitize
-* @returns The original URL if safe, or an empty string if the protocol is disallowed
-*
-* @example
-* ```ts
-* sanitizeUrl("https://example.com");       // "https://example.com"
-* sanitizeUrl("/about");                     // "/about"
-* sanitizeUrl("javascript:alert(1)");        // ""
-* sanitizeUrl("data:text/html,<h1>Hi</h1>"); // ""
-* ```
-*/ function sanitizeUrl(url) {
-	try {
-		const parsed = new URL(url, "https://placeholder.invalid");
-		if (SAFE_URL_PROTOCOLS.has(parsed.protocol)) return url;
-		return "";
-	} catch {
-		return "";
-	}
-}
-/**
-* Normalize a public site URL by stripping any trailing slash from the path.
-*
-* @param siteUrl - Full site URL, optionally with a path prefix
-* @returns Normalized site URL, or an empty string when not configured
-*/ function normalizeSiteUrl(siteUrl) {
-	const trimmed = siteUrl.trim();
-	if (!trimmed) return "";
-	const parsed = new URL(trimmed);
-	parsed.pathname = normalizeSitePathname(parsed.pathname) || "/";
-	if (parsed.pathname !== "/") parsed.pathname = parsed.pathname.replace(/\/+$/, "");
-	return parsed.toString().replace(/\/$/, parsed.pathname === "/" ? "/" : "");
-}
-/**
-* Extract the public path prefix from a full site URL.
-*
-* @param siteUrl - Full site URL
-* @returns Prefix like `/blog`, or an empty string when the site is rooted
-*/ function getSitePathPrefix(siteUrl) {
-	if (!siteUrl.trim()) return "";
-	return normalizeSitePathname(new URL(siteUrl).pathname);
-}
-/**
-* Extract the origin from a full site URL.
-*
-* @param siteUrl - Full site URL
-* @returns Origin like `https://example.com`, or an empty string when missing
-*/ function getSiteOrigin(siteUrl) {
-	if (!siteUrl.trim()) return "";
-	return new URL(siteUrl).origin;
-}
-/**
-* Build a normalized public site URL from an origin and optional path prefix.
-*
-* @param siteOrigin - Public site origin, such as `https://example.com`
-* @param sitePathPrefix - Public site path prefix, such as `/blog`
-* @returns Normalized site URL, or an empty string when no origin is configured
-*/ function buildSiteUrl(siteOrigin, sitePathPrefix = "") {
-	const trimmedOrigin = siteOrigin.trim();
-	if (!trimmedOrigin) return "";
-	const origin = new URL(trimmedOrigin).origin;
-	return normalizeSiteUrl(`${origin}${normalizeSitePathPrefix(sitePathPrefix) || "/"}`);
-}
-/**
-* Prefix an internal app path with the public site path prefix.
-*
-* Internal paths are always rooted at `/` and never include the deployment
-* prefix. This helper converts them to public-facing paths.
-*
-* @param path - Internal app path, such as `/settings`
-* @param sitePathPrefix - Public site path prefix, such as `/blog`
-* @returns Public path
-*/ function toPublicPath(path, sitePathPrefix = "") {
-	if (!path) return sitePathPrefix || "/";
-	const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-	if (!sitePathPrefix) return normalizedPath;
-	if (normalizedPath === sitePathPrefix || normalizedPath.startsWith(`${sitePathPrefix}/`)) return normalizedPath;
-	if (normalizedPath === "/") return sitePathPrefix;
-	return `${sitePathPrefix}${normalizedPath}`;
-}
-/**
-* Convert an app-local href to its public path while leaving external URLs
-* unchanged.
-*
-* @param href - Internal app path or external URL
-* @param sitePathPrefix - Public site path prefix
-* @returns Public-facing href
-*/ function toPublicHref(href, sitePathPrefix = "") {
-	if (href.startsWith("http://") || href.startsWith("https://") || href.startsWith("//") || href.startsWith("mailto:") || href.startsWith("tel:") || href.startsWith("#")) return href;
-	return toPublicPath(href, sitePathPrefix);
-}
-/**
-* Check whether a path is a safe same-origin redirect target.
-*
-* Accepts only paths that start with a single `/` (no protocol-relative
-* `//host`, no scheme, no control characters). Callers should use this to
-* validate user-supplied `redirect` query parameters before issuing a
-* `Location` header.
-*
-* @param path - Candidate redirect path
-* @returns `true` when the path is safe to use as an internal redirect
-*
-* @example
-* ```ts
-* isSafeInternalRedirect("/settings") // true
-* isSafeInternalRedirect("//evil.example") // false
-* isSafeInternalRedirect("https://evil.example") // false
-* ```
-*/ function isSafeInternalRedirect(path) {
-	if (typeof path !== "string") return false;
-	if (!path.startsWith("/")) return false;
-	if (path.startsWith("//")) return false;
-	if (path.startsWith("/\\")) return false;
-	for (let i = 0; i < path.length; i += 1) {
-		const code = path.charCodeAt(i);
-		if (code < 32 || code === 127) return false;
-	}
-	return true;
-}
-/**
-* Remove the site path prefix from a public request pathname.
-*
-* @param pathname - Public request pathname
-* @param sitePathPrefix - Configured public site path prefix
-* @returns Internal pathname, or `null` when the request is outside the site
-*/ function stripSitePathPrefix(pathname, sitePathPrefix) {
-	if (!sitePathPrefix) return pathname || "/";
-	if (pathname === sitePathPrefix) return "/";
-	if (pathname.startsWith(`${sitePathPrefix}/`)) return pathname.slice(sitePathPrefix.length) || "/";
-	return null;
-}
-/**
-* Convert an internal or public path into an absolute site URL.
-*
-* @param path - Internal app path or already-public path
-* @param siteUrl - Normalized site URL
-* @param sitePathPrefix - Public site path prefix
-* @returns Absolute URL when siteUrl is configured, otherwise the original path
-*/ function toAbsoluteSiteUrl(path, siteUrl, sitePathPrefix = "") {
-	if (!siteUrl) return toPublicPath(path, sitePathPrefix);
-	return new URL(toPublicPath(path, sitePathPrefix), siteUrl).toString();
-}
-/**
-* Resolve a possibly-relative asset URL to an absolute URL, leaving
-* already-absolute (`http(s):`) and protocol-relative (`//host`) URLs
-* untouched. Use for assets — like media — whose stored URL may be either an
-* app-local path or a full CDN URL.
-*
-* @param url - Asset URL: an internal path or an already-absolute URL
-* @param siteUrl - Normalized site URL
-* @param sitePathPrefix - Public site path prefix
-* @returns Absolute URL, or the original value when it is already absolute
-*
-* @example
-* ```ts
-* toAbsoluteAssetUrl("/m/a.png", "https://site.com");   // "https://site.com/m/a.png"
-* toAbsoluteAssetUrl("https://cdn.example/a.png", "x"); // "https://cdn.example/a.png"
-* ```
-*/ function toAbsoluteAssetUrl(url, siteUrl, sitePathPrefix = "") {
-	if (isFullUrl(url) || url.startsWith("//")) return url;
-	return toAbsoluteSiteUrl(url, siteUrl, sitePathPrefix);
-}
-//#endregion
-export { toPublicPath as _, getSitePathPrefix as a, __exportAll as b, normalizePath as c, sanitizeUrl as d, slugify as f, toPublicHref as g, toAbsoluteSiteUrl as h, getSiteOrigin as i, normalizeSitePathPrefix as l, toAbsoluteAssetUrl as m, extractDisplayDomain as n, isFullUrl as o, stripSitePathPrefix as p, extractDomain as r, isSafeInternalRedirect as s, buildSiteUrl as t, normalizeSiteUrl as u, toSameSitePath as v, url_exports as y };

package/src/client/__tests__/collection-created-notice.test.ts

@@ -1,36 +0,0 @@
-// @vitest-environment happy-dom
-
-import { beforeEach, describe, expect, it } from "vitest";
-import {
-  consumeCollectionCreatedNotice,
-  PENDING_COLLECTION_CREATED_STORAGE_KEY,
-  queueCollectionCreatedNotice,
-} from "../collection-created-notice.js";
-
-describe("collection created notice", () => {
-  beforeEach(() => {
-    globalThis.sessionStorage.clear();
-  });
-
-  it("queues and consumes the newly created Collection ID once", () => {
-    queueCollectionCreatedNotice("col_books");
-
-    expect(
-      globalThis.sessionStorage.getItem(PENDING_COLLECTION_CREATED_STORAGE_KEY),
-    ).toBe('{"collectionId":"col_books"}');
-    expect(consumeCollectionCreatedNotice()).toBe("col_books");
-    expect(consumeCollectionCreatedNotice()).toBeNull();
-  });
-
-  it("clears malformed pending state", () => {
-    globalThis.sessionStorage.setItem(
-      PENDING_COLLECTION_CREATED_STORAGE_KEY,
-      '{"collectionId":false}',
-    );
-
-    expect(consumeCollectionCreatedNotice()).toBeNull();
-    expect(
-      globalThis.sessionStorage.getItem(PENDING_COLLECTION_CREATED_STORAGE_KEY),
-    ).toBeNull();
-  });
-});

package/src/client/__tests__/collection-form-bridge.test.ts

@@ -1,216 +0,0 @@
-// @vitest-environment happy-dom
-
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-vi.mock("../toast.js", () => ({
-  showToast: vi.fn(),
-}));
-
-vi.mock("../collection-created-notice.js", () => ({
-  queueCollectionCreatedNotice: vi.fn(),
-}));
-
-import "../collection-form-bridge.js";
-
-type CollectionFormHarness = HTMLElement & {
-  cancelHref?: string;
-  initial?: {
-    slug?: string;
-  };
-  loading?: boolean;
-};
-
-function createPageForm(
-  cancelHref = "/collections",
-  initial: CollectionFormHarness["initial"] = { slug: "books" },
-): CollectionFormHarness {
-  document.body.innerHTML = `
-    <div
-      data-collection-editor-page
-      data-collection-editor-save-failed="Couldn't save. Try again in a moment."
-    >
-      <jant-collection-form></jant-collection-form>
-    </div>
-  `;
-
-  const formEl = document.querySelector(
-    "jant-collection-form",
-  ) as CollectionFormHarness | null;
-
-  if (!formEl) {
-    throw new Error("Expected collection form element");
-  }
-
-  formEl.cancelHref = cancelHref;
-  formEl.initial = initial;
-  return formEl;
-}
-
-async function flushAsyncWork() {
-  await new Promise((resolve) => setTimeout(resolve, 0));
-  await new Promise((resolve) => setTimeout(resolve, 0));
-}
-
-describe("collection form bridge", () => {
-  beforeEach(() => {
-    document.body.innerHTML = "";
-    vi.clearAllMocks();
-    vi.restoreAllMocks();
-    window.location.href = "http://localhost/collections/new";
-  });
-
-  it("redirects new collections back to the configured return URL", async () => {
-    const formEl = createPageForm("/collections");
-    const fetchSpy = vi.spyOn(globalThis, "fetch").mockResolvedValue(
-      new Response(JSON.stringify({ id: "col_books", slug: "books" }), {
-        status: 201,
-        headers: { "Content-Type": "application/json" },
-      }),
-    );
-
-    formEl.dispatchEvent(
-      new CustomEvent("jant:collection-submit", {
-        bubbles: true,
-        detail: {
-          endpoint: "/api/collections",
-          isEdit: false,
-          data: {
-            title: "Books",
-            slug: "books",
-          },
-        },
-      }),
-    );
-
-    await flushAsyncWork();
-
-    const { queueCollectionCreatedNotice } =
-      await import("../collection-created-notice.js");
-
-    expect(fetchSpy).toHaveBeenCalledWith("/api/collections", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-      },
-      body: JSON.stringify({
-        title: "Books",
-        slug: "books",
-      }),
-    });
-    expect(window.location.pathname).toBe("/collections");
-    expect(queueCollectionCreatedNotice).toHaveBeenCalledWith("col_books");
-  });
-
-  it("redirects edited collections back to the collections page when launched from the list", async () => {
-    const formEl = createPageForm("/collections");
-    const fetchSpy = vi.spyOn(globalThis, "fetch").mockResolvedValue(
-      new Response(JSON.stringify({ slug: "books-renamed" }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      }),
-    );
-
-    formEl.dispatchEvent(
-      new CustomEvent("jant:collection-submit", {
-        bubbles: true,
-        detail: {
-          endpoint: "/api/collections/collection-1",
-          isEdit: true,
-          data: {
-            title: "Books renamed",
-            slug: "books-renamed",
-          },
-        },
-      }),
-    );
-
-    await flushAsyncWork();
-
-    expect(fetchSpy).toHaveBeenCalledWith("/api/collections/collection-1", {
-      method: "PUT",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-      },
-      body: JSON.stringify({
-        title: "Books renamed",
-        slug: "books-renamed",
-      }),
-    });
-    expect(window.location.pathname).toBe("/collections");
-  });
-
-  it("redirects edited collections back to the updated detail page when launched from detail", async () => {
-    window.location.href =
-      "http://localhost/collections/books/edit?returnTo=%2Fbooks";
-    const formEl = createPageForm("/books");
-    vi.spyOn(globalThis, "fetch").mockResolvedValue(
-      new Response(JSON.stringify({ slug: "books-renamed" }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      }),
-    );
-
-    formEl.dispatchEvent(
-      new CustomEvent("jant:collection-submit", {
-        bubbles: true,
-        detail: {
-          endpoint: "/api/collections/collection-1",
-          isEdit: true,
-          data: {
-            title: "Books renamed",
-            slug: "books-renamed",
-          },
-        },
-      }),
-    );
-
-    await flushAsyncWork();
-
-    expect(window.location.pathname).toBe("/books-renamed");
-  });
-
-  it("rewrites aggregate return paths when a collection slug changes", async () => {
-    window.location.href =
-      "http://localhost/collections/books/edit?returnTo=%2Fcollections%2Fbooks%2Bessays";
-    const formEl = createPageForm("/collections/books+essays", {
-      slug: "books",
-    });
-    const fetchSpy = vi.spyOn(globalThis, "fetch").mockResolvedValue(
-      new Response(JSON.stringify({ slug: "books-renamed" }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      }),
-    );
-
-    formEl.dispatchEvent(
-      new CustomEvent("jant:collection-submit", {
-        bubbles: true,
-        detail: {
-          endpoint: "/api/collections/collection-1",
-          isEdit: true,
-          data: {
-            title: "Books renamed",
-            slug: "books-renamed",
-          },
-        },
-      }),
-    );
-
-    await flushAsyncWork();
-
-    expect(fetchSpy).toHaveBeenCalledWith("/api/collections/collection-1", {
-      method: "PUT",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-      },
-      body: JSON.stringify({
-        title: "Books renamed",
-        slug: "books-renamed",
-      }),
-    });
-    expect(window.location.pathname).toBe("/collections/books-renamed+essays");
-  });
-});