camox 0.43.0 → 0.45.0

package/dist/core/lib/textLinks.js

@@ -1,8 +1,9 @@
+import { PAGE_TEXT_LINK_PREFIX } from "@camox/api-contract/ids";
+
 //#region src/core/lib/textLinks.ts
-const PAGE_TEXT_LINK_PREFIX = "camox:page:";
 function getPageIdFromTextLinkTarget(target) {
-	if (!target.startsWith("camox:page:")) return null;
-	const pageId = target.slice(11);
+	if (!target.startsWith(PAGE_TEXT_LINK_PREFIX)) return null;
+	const pageId = target.slice(PAGE_TEXT_LINK_PREFIX.length);
 	if (!pageId) return null;
 	return pageId;
 }
@@ -21,11 +22,12 @@ function isValidTextLinkTarget(target) {
 function resolveTextLinkHref(target, pages, fallbackHref) {
 	const pageId = getPageIdFromTextLinkTarget(target);
 	if (pageId == null) return isValidTextLinkTarget(target) ? target : null;
-	return (pages?.find((p) => String(p.id) === pageId))?.fullPath ?? fallbackHref;
+	if (!pages) return fallbackHref;
+	return pages.find((p) => p.id === pageId)?.fullPath ?? null;
 }
 function shouldOpenTextLinkInNewTab(target) {
 	return isHttpTextLinkTarget(target);
 }
 
 //#endregion
-export { createPageTextLinkTarget, getPageIdFromTextLinkTarget, isHttpTextLinkTarget, isValidTextLinkTarget, resolveTextLinkHref, shouldOpenTextLinkInNewTab };
+export { createPageTextLinkTarget, getPageIdFromTextLinkTarget, isHttpTextLinkTarget, isInternalTextLinkTarget, isValidTextLinkTarget, resolveTextLinkHref, shouldOpenTextLinkInNewTab };

package/dist/core/lib/textStyles.d.ts

@@ -1,27 +1,25 @@
 import { CSSProperties } from "react";
-
 //#region src/core/lib/textStyles.d.ts
-interface InlineStyle {
+export interface InlineStyle {
   className?: string;
   style?: CSSProperties;
 }
-interface TextStyleData {
+export interface TextStyleData {
   /** True when styling the shared highlight wrapper. Other flags are false for this call. */
   highlight: boolean;
   bold: boolean;
   italic: boolean;
-  underline: boolean;
+  strikethrough: boolean;
 }
-interface TextLinkStyleData {
+export interface TextLinkStyleData {
   target: string;
   href: string;
   external: boolean;
   pageId?: string;
 }
 /** Appearance only: Camox owns inline elements in both rendering modes. */
-interface InlineTextStyles {
+export interface InlineTextStyles {
   textStyle?: (format: TextStyleData) => InlineStyle | undefined;
   linkStyle?: (link: TextLinkStyleData) => InlineStyle | undefined;
 }
-//#endregion
-export { InlineStyle, InlineTextStyles, TextLinkStyleData, TextStyleData };
+//#endregion

package/dist/core/lib/textStyles.js

@@ -6,7 +6,7 @@ function getTextStyleData(format) {
 		highlight: false,
 		bold: !!(format & FORMAT_FLAGS.bold),
 		italic: !!(format & FORMAT_FLAGS.italic),
-		underline: !!(format & FORMAT_FLAGS.underline)
+		strikethrough: !!(format & FORMAT_FLAGS.strikethrough)
 	};
 }
 function getTextAppearance(format, styles) {
@@ -16,18 +16,18 @@ function getTextAppearance(format, styles) {
 		className: custom?.className,
 		style: {
 			...flags.bold && flags.italic ? { fontStyle: "italic" } : {},
-			...flags.underline ? { textDecorationLine: "underline" } : {},
+			...flags.strikethrough ? { textDecorationLine: "line-through" } : {},
 			...custom?.style
 		}
 	};
 }
-const defaultHighlightStyle = { color: "var(--primary, currentColor)" };
+const defaultHighlightStyle = { color: "var(--camox-highlight, currentColor)" };
 function getHighlightStyle(styles) {
 	const custom = styles.textStyle?.({
 		highlight: true,
 		bold: false,
 		italic: false,
-		underline: false
+		strikethrough: false
 	});
 	return {
 		className: custom?.className,
@@ -39,4 +39,4 @@ function getHighlightStyle(styles) {
 }
 
 //#endregion
-export { getHighlightStyle, getTextAppearance };
+export { defaultHighlightStyle, getHighlightStyle, getTextAppearance, getTextStyleData };

package/dist/core/notFound.d.ts

@@ -0,0 +1,7 @@
+//#region src/core/notFound.d.ts
+/** Signal a missing derived page; other loader failures remain server errors. */
+export declare function notFound(): Error & {
+  status: number;
+  code: string;
+};
+//#endregion

package/dist/core/notFound.js

@@ -0,0 +1,11 @@
+//#region src/core/notFound.ts
+/** Signal a missing derived page; other loader failures remain server errors. */
+function notFound() {
+	return Object.assign(/* @__PURE__ */ new Error("Page not found"), {
+		status: 404,
+		code: "NOT_FOUND"
+	});
+}
+
+//#endregion
+export { notFound };

package/dist/core/pageDestinations.js

@@ -1,9 +1,12 @@
 import { createPageTextLinkTarget } from "./lib/textLinks.js";
 
 //#region src/core/pageDestinations.ts
-/** Concrete navigable pages, not records that can all be mutated through pages.*. */
+/**
+* Concrete navigable pages, not records that can all be mutated through pages.*. Pages whose
+* layout is gone, or whose URL a singleton serves, aren't served, so they aren't destinations.
+*/
 function getPageDestinations(pages, layouts) {
-	return [...pages.map((page) => ({
+	return [...pages.filter((page) => !page.needsLayout && !page.shadowed).map((page) => ({
 		key: `page:${page.id}`,
 		kind: "curated",
 		pageId: page.id,
@@ -21,7 +24,7 @@ function getPageDestinations(pages, layouts) {
 function destinationLink(destination) {
 	if (destination.kind === "curated") return {
 		type: "page",
-		pageId: String(destination.pageId)
+		pageId: destination.pageId
 	};
 	return {
 		type: "external",

package/dist/core/recordItem.js

@@ -0,0 +1,34 @@
+import { resolveToMarkdown } from "./lib/contentType.js";
+import { isLexicalState, lexicalStateToPlainText } from "./lib/lexicalState.js";
+
+//#region src/core/recordItem.ts
+/**
+* The value when it names a collection record (a `collection-item` loader result or route
+* target), otherwise undefined.
+*/
+function asCollectionItem(value) {
+	if (value?.kind !== "collection-item") return void 0;
+	return value;
+}
+/** A record page's String fields as plain text, as its meta callbacks get them. */
+function recordPlainText(collection, content) {
+	const properties = collection._internal.contentSchema.properties;
+	const text = {};
+	for (const [name, field] of Object.entries(properties)) if (field.fieldType === "String") text[name] = fieldPlainText(content[name]);
+	return text;
+}
+/** A String field's text, whether it is stored as plain text or rich-text state. */
+function fieldPlainText(value) {
+	if (typeof value !== "string" && !isLexicalState(value)) return "";
+	return lexicalStateToPlainText(value);
+}
+/**
+* Runs a record layout's `toMarkdown` with `item` as the reference-list Markdown builder. Its
+* field tokens are left for the API to fill with the live record.
+*/
+function recordMarkdownTemplate(collection, toMarkdown) {
+	return resolveToMarkdown((item) => toMarkdown(item), void 0, "item", collection._internal.contentSchema.properties);
+}
+
+//#endregion
+export { asCollectionItem, fieldPlainText, recordMarkdownTemplate, recordPlainText };

package/dist/core/requestContext.d.ts

@@ -0,0 +1,26 @@
+import { ReferenceRecord } from "./lib/reference.js";
+//#region src/core/requestContext.d.ts
+declare const requestContextBrand: unique symbol;
+/**
+ * Opaque: pass it through unchanged. Camox gives it to `loader` and `routes` so that
+ * collection helpers read the request's content.
+ */
+export interface LayoutRequestContext {
+  readonly [requestContextBrand]: true;
+}
+/** Names one collection record, whatever its content. */
+export interface CollectionRecordId {
+  collectionId: string;
+  id: string;
+}
+/** A collection record as a record page loads it. */
+export interface LoadedRecord<Content = Record<string, unknown>> {
+  id: string;
+  content: Content;
+  /** The records it links, resolved by Camox with the record as the first hop. */
+  references?: ReferenceRecord["references"];
+  /** When its content last changed. */
+  updatedAt?: number;
+}
+//#endregion
+export {};

package/dist/core/requestContext.js

@@ -0,0 +1,20 @@
+//#region src/core/requestContext.ts
+const states = /* @__PURE__ */ new WeakMap();
+function createRequestContext(state) {
+	const context = Object.freeze({});
+	states.set(context, state);
+	return context;
+}
+function getState(context) {
+	const state = states.get(context);
+	if (!state) throw new Error("Camox request context is missing: pass the loader's context through unchanged");
+	return state;
+}
+function getRecordLookup(context) {
+	const { records } = getState(context);
+	if (!records) throw new Error("Camox can't read collection records: its API is not configured");
+	return records;
+}
+
+//#endregion
+export { createRequestContext, getRecordLookup };