camox 0.44.0 → 0.45.0

package/dist/lib/html.js

@@ -0,0 +1,12 @@
+//#region src/lib/html.ts
+/** `value`, safe inside a double-quoted HTML attribute. */
+function escapeAttribute(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;");
+}
+/** `value` as JSON that can't close the `<script>` element it's written into. */
+function serializeJsonForHtml(value) {
+	return JSON.stringify(value).replaceAll("<", "\\u003c");
+}
+
+//#endregion
+export { escapeAttribute, serializeJsonForHtml };

package/dist/lib/link-pages.js

@@ -0,0 +1,154 @@
+import { UNNAMED_DEFAULT_LOCALE, localizedPath } from "./locale-path.js";
+import { useViewLocale } from "./view-locale-context.js";
+import { reads, useReadQuery } from "./studio-reads.js";
+import { c } from "react/compiler-runtime";
+
+//#region src/lib/link-pages.ts
+/**
+* The locale whose pages links fall back to from `locale`: the default locale, or none in the
+* default locale itself. Its tag is never read: reads name the default locale by none.
+*/
+function linkFallbackLocale(locale) {
+	return locale.isDefault ? null : UNNAMED_DEFAULT_LOCALE;
+}
+/**
+* The pages a link can lead to from a locale, given its pages and its fallback locale's: its own,
+* then the fallback's pages it has no localization of.
+*/
+function linkablePages(pages, fallbackPages) {
+	const own = new Set(pages.map((page) => page.id));
+	return [...pages.map((page) => ({
+		page,
+		own: true
+	})), ...(fallbackPages ?? []).filter((page) => !own.has(page.id)).map((page) => ({
+		page,
+		own: false
+	}))];
+}
+/**
+* The pages links lead to in `locale`, at their paths: its own pages under its prefix, then the
+* default locale's pages it misses. Undefined until the locale's pages load.
+*/
+function linkPagesIn(locale, pages, fallbackPages) {
+	if (!pages) return void 0;
+	return linkablePages(pages, fallbackPages).map(({ page, own }) => ({
+		id: page.id,
+		fullPath: own ? localizedPath(page.fullPath, locale) : page.fullPath
+	}));
+}
+/**
+* Selects the page list as is. Selected values keep their identity while their content does, so
+* fields don't re-render when a frame hydrates an equal list.
+*/
+const samePageList = (pages) => pages;
+/** Selects only that a read loaded, so fields don't re-render as its value changes. */
+const isLoaded = () => true;
+/**
+* The pages a link can lead to in the locale viewed (see `linkablePages`), undefined until they
+* load. A site render seeds them, so by default the project they wait for is read from the cache
+* only: an anonymous visitor may not read the project, so fetching it would fail. The studio's
+* editors fetch it with `fetchProject`.
+*/
+function useLinkablePages(projectUuid, t0) {
+	const $ = c(21);
+	let t1;
+	if ($[0] !== t0) {
+		t1 = t0 === void 0 ? {} : t0;
+		$[0] = t0;
+		$[1] = t1;
+	} else t1 = $[1];
+	const { fetchProject: t2 } = t1;
+	const fetchProject = t2 === void 0 ? false : t2;
+	const { locale } = useViewLocale();
+	let t3;
+	if ($[2] !== locale) {
+		t3 = linkFallbackLocale(locale);
+		$[2] = locale;
+		$[3] = t3;
+	} else t3 = $[3];
+	const fallback = t3;
+	let t4;
+	if ($[4] !== projectUuid) {
+		t4 = reads.project({ projectUuid });
+		$[4] = projectUuid;
+		$[5] = t4;
+	} else t4 = $[5];
+	let t5;
+	if ($[6] !== fetchProject) {
+		t5 = {
+			enabled: fetchProject,
+			select: isLoaded
+		};
+		$[6] = fetchProject;
+		$[7] = t5;
+	} else t5 = $[7];
+	const { data: projectLoaded } = useReadQuery(t4, t5);
+	let t6;
+	if ($[8] !== projectUuid) {
+		t6 = reads.pageList({ projectUuid });
+		$[8] = projectUuid;
+		$[9] = t6;
+	} else t6 = $[9];
+	const t7 = !!projectLoaded;
+	let t8;
+	if ($[10] !== t7) {
+		t8 = {
+			enabled: t7,
+			select: samePageList
+		};
+		$[10] = t7;
+		$[11] = t8;
+	} else t8 = $[11];
+	const { data: pages } = useReadQuery(t6, t8);
+	let t9;
+	if ($[12] !== projectUuid) {
+		t9 = reads.pageList({ projectUuid });
+		$[12] = projectUuid;
+		$[13] = t9;
+	} else t9 = $[13];
+	const t10 = !!projectLoaded && fallback !== null;
+	const t11 = fallback ?? void 0;
+	let t12;
+	if ($[14] !== t10 || $[15] !== t11) {
+		t12 = {
+			enabled: t10,
+			locale: t11,
+			select: samePageList
+		};
+		$[14] = t10;
+		$[15] = t11;
+		$[16] = t12;
+	} else t12 = $[16];
+	const { data: fallbackPages } = useReadQuery(t9, t12);
+	const t13 = fallback ? fallbackPages : void 0;
+	let t14;
+	if ($[17] !== locale || $[18] !== pages || $[19] !== t13) {
+		t14 = {
+			locale,
+			pages,
+			fallbackPages: t13
+		};
+		$[17] = locale;
+		$[18] = pages;
+		$[19] = t13;
+		$[20] = t14;
+	} else t14 = $[20];
+	return t14;
+}
+/** The pages links lead to in the locale viewed, at their paths (see `linkPagesIn`). */
+function useLinkPages(projectUuid, options) {
+	const $ = c(4);
+	const { locale, pages, fallbackPages } = useLinkablePages(projectUuid, options);
+	let t0;
+	if ($[0] !== fallbackPages || $[1] !== locale || $[2] !== pages) {
+		t0 = linkPagesIn(locale, pages, fallbackPages);
+		$[0] = fallbackPages;
+		$[1] = locale;
+		$[2] = pages;
+		$[3] = t0;
+	} else t0 = $[3];
+	return t0;
+}
+
+//#endregion
+export { linkFallbackLocale, linkPagesIn, linkablePages, useLinkPages, useLinkablePages };

package/dist/lib/locale-path.d.ts

@@ -0,0 +1,22 @@
+//#region src/lib/locale-path.d.ts
+/**
+ * The URL names the locale: a non-default locale's paths sit under its prefix (`/de/preise`), the
+ * default locale's have none. The studio's routes follow the same rule (`/de/camox/content`).
+ * Pure, so the runtime and the browser share it.
+ */
+/** A locale of a project, as `locales.list` returns it. */
+export type LocaleView = {
+  tag: string;
+  isDefault: boolean;
+};
+/**
+ * Where a page sits in one locale it exists in: the locale's tag and the page's path there, under
+ * the locale's prefix. The runtime finds them for `hreflang` links and the sitemap; the
+ * alternates hook turns each into an `Alternate` a switcher links to.
+ */
+export interface AlternatePath {
+  locale: string;
+  /** The page's runtime path, with its locale's prefix and without the runtime base path. */
+  path: string;
+}
+//#endregion

package/dist/lib/locale-path.js

@@ -0,0 +1,57 @@
+import { LOCALE_HEADER } from "@camox/api-contract/drafts";
+
+//#region src/lib/locale-path.ts
+/**
+* The URL names the locale: a non-default locale's paths sit under its prefix (`/de/preise`), the
+* default locale's have none. The studio's routes follow the same rule (`/de/camox/content`).
+* Pure, so the runtime and the browser share it.
+*/
+/**
+* The default locale where nothing says its tag yet: before a render shows a locale, outside the
+* page runtime, or without an API to read the project's locales from.
+*/
+const UNNAMED_DEFAULT_LOCALE = {
+	tag: "und",
+	isDefault: true
+};
+/**
+* The headers naming `locale` in a request (`LOCALE_HEADER`). The default locale is the API's own
+* default, so only another locale is named.
+*/
+function localeHeaders(locale) {
+	return locale && !locale.isDefault ? { [LOCALE_HEADER]: locale.tag } : {};
+}
+/** A locale's URL prefix: its tag in lowercase. The default locale has none. */
+function localePrefix(locale) {
+	return locale.isDefault ? "" : `/${locale.tag.toLowerCase()}`;
+}
+/**
+* The locale a runtime path names, and the path after its prefix, without search or hash. A first
+* segment that isn't a non-default locale's prefix leaves the path the default locale's. A
+* locale's home is `/de`; `/de/` names it too.
+*/
+function parseLocalePath(pathname, locales) {
+	const path = pathname.replace(/[?#].*$/s, "") || "/";
+	const end = path.indexOf("/", 1);
+	const segment = end === -1 ? path.slice(1) : path.slice(1, end);
+	const named = locales.find((locale) => !locale.isDefault && localePrefix(locale) === `/${segment}`);
+	if (named) return {
+		locale: named,
+		path: end === -1 ? "/" : path.slice(end)
+	};
+	const fallback = locales.find((locale) => locale.isDefault);
+	if (!fallback) throw new Error("A project's locales include its default locale.");
+	return {
+		locale: fallback,
+		path
+	};
+}
+/** A locale-relative path under its locale's prefix, keeping its search and hash: `/` is `/de`. */
+function localizedPath(path, locale) {
+	const prefix = localePrefix(locale);
+	if (!prefix) return path;
+	return path === "/" || /^\/[?#]/.test(path) ? `${prefix}${path.slice(1)}` : `${prefix}${path}`;
+}
+
+//#endregion
+export { UNNAMED_DEFAULT_LOCALE, localeHeaders, localePrefix, localizedPath, parseLocalePath };