camox 0.43.0 → 0.45.0

package/dist/core/lib/contentType.js

@@ -1,7 +1,16 @@
+import { attachArtifactData } from "./artifactData.js";
+import { referenceQueryProblem } from "@camox/api-contract";
 import { Type } from "@sinclair/typebox";
+import { uuidv7JsonSchema } from "@camox/api-contract/ids";
 
 //#region src/core/lib/contentType.ts
+/** A collection's content field named `key`, if it has one. */
+function collectionField(collection, key) {
+	const properties = collection?._internal.contentSchema.properties;
+	return properties && Object.hasOwn(properties, key) ? properties[key] : void 0;
+}
 var FieldToken = class {
+	fieldName;
 	constructor(fieldName) {
 		this.fieldName = fieldName;
 	}
@@ -15,6 +24,10 @@ var FieldToken = class {
 * server-side resolver knows whether to read from `settings` or `itemSettings`.
 */
 var Conditional = class {
+	scope;
+	settingName;
+	enumValue;
+	children;
 	constructor(scope, settingName, enumValue, children) {
 		this.scope = scope;
 		this.settingName = settingName;
@@ -30,10 +43,13 @@ var Conditional = class {
 		return "{{/if}}";
 	}
 };
-function createContentProxy() {
+function createContentProxy(shape, prefix = "") {
 	return new Proxy({}, { get(_target, prop) {
 		if (typeof prop !== "string") return void 0;
-		return new FieldToken(prop);
+		const path = prefix ? `${prefix}.${prop}` : prop;
+		const field = shape?.[prop];
+		if (field?.fieldType === "Reference") return createContentProxy(field.referenceSchema.properties, path);
+		return new FieldToken(path);
 	} });
 }
 function createSettingsProxy(settingsShape, scope) {
@@ -52,13 +68,22 @@ function serializeConditional(cond) {
 	else out.push(`${cond.openTag}${String(child)}${cond.closeTag}`);
 	return out;
 }
-function resolveToMarkdown(builder, settingsShape, scope) {
-	const entries = builder(createContentProxy(), createSettingsProxy(settingsShape, scope));
+function resolveToMarkdown(builder, settingsShape, scope, contentShape) {
+	const entries = builder(createContentProxy(contentShape), createSettingsProxy(settingsShape, scope));
 	const out = [];
 	for (const entry of entries) if (entry instanceof Conditional) out.push(...serializeConditional(entry));
 	else out.push(entry instanceof FieldToken ? entry.toString() : String(entry));
 	return out;
 }
+/** The longest artifact source content writes accept (256 KB). */
+const ARTIFACT_MAX_LENGTH = 262144;
+const IMAGE_PLACEHOLDER = Symbol("camox.imagePlaceholder");
+function isImagePlaceholder(value) {
+	return typeof Reflect.get(value, IMAGE_PLACEHOLDER) === "string" && !value._fileId;
+}
+function getImagePlaceholderTitle(value) {
+	return Reflect.get(value, IMAGE_PLACEHOLDER);
+}
 function _imageSingle(options) {
 	return Type.Unsafe({
 		type: "object",
@@ -69,11 +94,13 @@ function _imageSingle(options) {
 			mimeType: { type: "string" }
 		},
 		accept: ["image/*"],
+		required: options.required ?? false,
 		default: {
 			url: `https://placehold.co/1200x800/f4f4f5/a1a1aa.png?text=${options?.title || "image"}`,
 			alt: "",
 			filename: "placeholder.png",
-			mimeType: "image/png"
+			mimeType: "image/png",
+			[IMAGE_PLACEHOLDER]: options.title || "image"
 		},
 		title: options.title,
 		fieldType: "Image"
@@ -99,6 +126,7 @@ function _fileSingle(options) {
 			mimeType: { type: "string" }
 		},
 		accept: options.accept,
+		required: options.required ?? false,
 		default: {
 			url: "https://placehold.co/file-placeholder",
 			alt: "",
@@ -123,186 +151,197 @@ function _fileList(options) {
 	});
 }
 /**
-* Type builders for createBlock content schemas.
-* All fields must have default values.
+* Checks a query against its collection, for callers that bypass the types (computed limits
+* included); definition sync applies the same rules.
 */
-const Type$1 = {
-	/**
-	* Creates a string field with a required default value.
-	*
-	* @example
-	* Type.String({ default: 'Hello' })
-	* Type.String({ default: 'Hello', maxLength: 100, title: 'Title' })
-	*/
-	String: (options) => {
+function validateQuery(query, collection) {
+	const problem = referenceQueryProblem(query, (key) => collectionField(collection, key)?.fieldType);
+	if (problem) throw new Error(`Query on "${collection._internal.id}": ${problem}`);
+	return query;
+}
+const settingKinds = /* @__PURE__ */ new Set(["Enum", "Boolean"]);
+/** Builders are typed per context; this guards callers that bypass the types. */
+function assertFieldKinds(shape, context, owner) {
+	for (const [key, field] of Object.entries(shape)) {
+		const isSetting = settingKinds.has(field.fieldType);
+		if (context === "settings" && !isSetting) throw new Error(`${owner} setting "${key}" must be an enum or a boolean`);
+		if (context === "content" && isSetting) throw new Error(`${owner} field "${key}": ${field.fieldType} is a setting, not content`);
+	}
+}
+function collectSchemaDefaults(properties) {
+	const defaults = {};
+	for (const [key, prop] of Object.entries(properties)) if ("default" in prop) defaults[key] = prop.default;
+	return defaults;
+}
+const enumSetting = (options) => Type.Unsafe({
+	type: "string",
+	enum: Object.keys(options.options),
+	default: options.default,
+	title: options.title,
+	enumLabels: options.options,
+	fieldType: "Enum"
+});
+const booleanSetting = (options) => Type.Boolean({
+	default: options.default,
+	title: options.title,
+	fieldType: "Boolean"
+});
+const settingBuilder = {
+	enum: enumSetting,
+	boolean: booleanSetting
+};
+const contentFieldBuilder = {
+	string: (options) => Type.Unsafe({
+		type: "string",
+		...options,
+		fieldType: "String"
+	}),
+	link: (options) => Type.Unsafe({
+		type: "object",
+		properties: {
+			type: {
+				type: "string",
+				enum: ["external", "page"]
+			},
+			text: { type: "string" },
+			href: { type: "string" },
+			pageId: { anyOf: [{ const: "" }, uuidv7JsonSchema] },
+			newTab: { type: "boolean" }
+		},
+		default: {
+			...options.default,
+			type: "external"
+		},
+		title: options.title,
+		fieldType: "Link"
+	}),
+	image: (options = {}) => _imageSingle(options),
+	imageList: (options = {}) => _imageList(options),
+	file: (options) => _fileSingle(options),
+	fileList: (options) => _fileList(options),
+	embed: (options) => {
+		if (!new RegExp(options.pattern).test(options.default)) throw new Error(`Embed default value "${options.default}" does not match pattern "${options.pattern}"`);
 		return Type.Unsafe({
 			type: "string",
-			...options,
+			pattern: options.pattern,
 			default: options.default,
-			fieldType: "String"
+			title: options.title,
+			fieldType: "Embed"
 		});
 	},
-	/**
-	* Creates a repeatable array of object items.
-	* The default array is auto-generated based on minItems.
-	*
-	* Items may also declare per-item `settings` (Enum/Boolean only) — not
-	* inline-editable; they appear in the sidebar when the item is selected,
-	* similar to block-level settings.
-	*
-	* @example
-	* Type.Repeater({
-	*   content: {
-	*     title: Type.String({ default: 'Item' }),
-	*     description: Type.String({ default: 'Description' }),
-	*   },
-	*   settings: {
-	*     highlighted: Type.Boolean({ default: false, title: 'Highlighted' }),
-	*   },
-	*   minItems: 1,
-	*   maxItems: 10,
-	*   title: 'Items',
-	*   toMarkdown: (c) => [`### ${c.title}`, c.description],
-	* })
-	*/
-	Repeater: (options) => {
+	artifact: (options) => Type.Unsafe({
+		type: "string",
+		maxLength: ARTIFACT_MAX_LENGTH,
+		size: options.size,
+		...options.data?.length ? { data: [...options.data] } : {},
+		default: options.default ?? "",
+		title: options.title,
+		fieldType: "Artifact"
+	}),
+	icon: (options) => {
+		const ids = typeof __CAMOX_ICON_IDS__ === "undefined" ? [] : __CAMOX_ICON_IDS__;
+		if (!ids.includes(options.default)) throw new Error(`Invalid icon default "${String(options.default)}". Configure icons in camox() first.`);
+		return Type.Unsafe({
+			type: "string",
+			fieldType: "Icon",
+			enum: [...ids],
+			default: options.default,
+			title: options.title
+		});
+	},
+	reference: (collection, options = {}) => Type.Unsafe({
+		anyOf: [{
+			type: "string",
+			format: "uuid"
+		}, { type: "null" }],
+		fieldType: "Reference",
+		collectionId: collection._internal.id,
+		required: options.required ?? false,
+		title: options.title ?? collection._internal.title,
+		default: null,
+		referenceSchema: collection._internal.contentSchema,
+		labelField: collection._internal.label
+	}),
+	referenceList: (collection, options = {}) => Type.Unsafe({
+		type: "array",
+		items: {
+			type: "string",
+			format: "uuid"
+		},
+		fieldType: "ReferenceList",
+		collectionId: collection._internal.id,
+		title: options.title ?? collection._internal.title,
+		...options.description === void 0 ? {} : { description: options.description },
+		...options.maxItems === void 0 ? {} : { maxItems: options.maxItems },
+		...options.query === void 0 ? { default: [] } : { query: validateQuery(options.query, collection) },
+		...options.toMarkdown === void 0 ? {} : { toMarkdown: resolveToMarkdown(options.toMarkdown, void 0, "item", collection._internal.contentSchema.properties) },
+		referenceSchema: collection._internal.contentSchema,
+		labelField: collection._internal.label
+	}),
+	repeater: (options) => {
 		if (options.minItems < 1) throw new Error("Repeater requires minItems to be at least 1");
-		const objectSchema = Type.Object(options.content);
-		const defaultItem = {};
-		for (const [key, prop] of Object.entries(objectSchema.properties)) if ("default" in prop) defaultItem[key] = prop.default;
+		const content = options.content(contentFieldBuilder);
+		const settings = options.settings?.(settingBuilder);
+		const owner = `Repeater${options.title ? ` "${options.title}"` : ""}`;
+		assertFieldKinds(content, "content", owner);
+		if (settings) assertFieldKinds(settings, "settings", owner);
+		attachArtifactData(content, settings, owner);
+		const objectSchema = Type.Object(content);
+		const defaultItem = collectSchemaDefaults(objectSchema.properties);
 		const defaultArray = Array(options.minItems).fill(null).map(() => ({ ...defaultItem }));
-		const settingsTypeboxSchema = options.settings ? Type.Object(options.settings) : null;
-		const itemSettingsSchema = settingsTypeboxSchema ? {
+		const settingsObjectSchema = settings ? Type.Object(settings) : null;
+		const itemSettingsSchema = settingsObjectSchema ? {
 			type: "object",
-			properties: settingsTypeboxSchema.properties,
-			required: Object.keys(options.settings)
+			properties: settingsObjectSchema.properties,
+			required: Object.keys(settingsObjectSchema.properties)
 		} : void 0;
-		const defaultItemSettings = {};
-		if (settingsTypeboxSchema) {
-			for (const [key, prop] of Object.entries(settingsTypeboxSchema.properties)) if ("default" in prop) defaultItemSettings[key] = prop.default;
-		}
 		return Type.Array(objectSchema, {
 			minItems: options.minItems,
-			maxItems: options.maxItems,
+			...Number.isFinite(options.maxItems) ? { maxItems: options.maxItems } : {},
 			default: defaultArray,
 			title: options.title,
 			fieldType: "Repeater",
-			toMarkdown: resolveToMarkdown(options.toMarkdown, options.settings, "item"),
+			toMarkdown: resolveToMarkdown(options.toMarkdown, settings, "item", content),
 			itemSettingsSchema,
-			defaultItemSettings: settingsTypeboxSchema ? defaultItemSettings : void 0
+			defaultItemSettings: settingsObjectSchema ? collectSchemaDefaults(settingsObjectSchema.properties) : void 0
 		});
-	},
-	/**
-	* Creates an enum field with a set of predefined options.
-	*
-	* @example
-	* Type.Enum({
-	*   default: 'left',
-	*   options: { left: 'Left', center: 'Center', right: 'Right' },
-	*   title: 'Alignment'
-	* })
-	*/
-	Enum: (options) => {
-		const enumValues = Object.keys(options.options);
-		return Type.Unsafe({
-			type: "string",
-			enum: enumValues,
-			default: options.default,
-			title: options.title,
-			enumLabels: options.options,
-			fieldType: "Enum"
-		});
-	},
-	/**
-	* Creates a boolean toggle field.
-	*
-	* @example
-	* Type.Boolean({ default: false, title: 'Show background' })
-	*/
-	Boolean: (options) => {
-		return Type.Boolean({
-			default: options.default,
-			title: options.title,
-			fieldType: "Boolean"
-		});
-	},
-	/**
-	* Creates an embed field for URLs matching a specific pattern.
-	*
-	* @example
-	* Type.Embed({
-	*   pattern: 'https:\\/\\/(www\\.)?youtube\\.com\\/watch\\?v=.+',
-	*   default: 'https://www.youtube.com/watch?v=dQw4w9WgXcQ',
-	*   title: 'YouTube URL'
-	* })
-	*/
-	Embed: (options) => {
-		if (!new RegExp(options.pattern).test(options.default)) throw new Error(`Embed default value "${options.default}" does not match pattern "${options.pattern}"`);
-		return Type.Unsafe({
-			type: "string",
-			pattern: options.pattern,
-			default: options.default,
-			title: options.title,
-			fieldType: "Embed"
-		});
-	},
-	/**
-	* Creates a link field with text, href/pageId, and newTab properties.
-	* Supports both external URLs and internal page links.
-	*
-	* @example
-	* Type.Link({ default: { text: 'Learn more', href: '/', newTab: false }, title: 'CTA' })
-	*/
-	Link: (options) => {
-		return Type.Unsafe({
-			type: "object",
-			properties: {
-				type: {
-					type: "string",
-					enum: ["external", "page"]
-				},
-				text: { type: "string" },
-				href: { type: "string" },
-				pageId: { type: "string" },
-				newTab: { type: "boolean" }
-			},
-			default: {
-				...options.default,
-				type: "external"
-			},
-			title: options.title,
-			fieldType: "Link"
-		});
-	},
-	/**
-	* Creates an image asset field.
-	*
-	* @example
-	* Type.Image({ title: 'Hero' })
-	*/
-	Image: (options = {}) => _imageSingle(options),
-	/**
-	* Creates a file asset field.
-	*
-	* @example
-	* Type.File({ accept: ['application/pdf'], title: 'Datasheet' })
-	*/
-	File: (options) => _fileSingle(options),
-	/**
-	* Creates an array of image assets.
-	*
-	* @example
-	* Type.ImageList({ title: 'Gallery', defaultItems: 3 })
-	*/
-	ImageList: (options = {}) => _imageList(options),
-	/**
-	* Creates an array of file assets.
-	*
-	* @example
-	* Type.FileList({ accept: ['application/pdf'], title: 'Attachments' })
-	*/
-	FileList: (options) => _fileList(options)
+	}
 };
+const collectionFieldBuilder = {
+	string: (options = {}) => Type.Unsafe({
+		type: "string",
+		...options,
+		fieldType: "String"
+	}),
+	enum: enumSetting,
+	boolean: booleanSetting,
+	image: (options = {}) => contentFieldBuilder.image({ title: options.title }),
+	imageList: contentFieldBuilder.imageList,
+	file: (options) => contentFieldBuilder.file({
+		accept: options.accept,
+		title: options.title
+	}),
+	fileList: contentFieldBuilder.fileList,
+	embed: contentFieldBuilder.embed,
+	reference: (collection, options = {}) => contentFieldBuilder.reference(collection, { title: options.title }),
+	referenceList: (collection, options = {}) => {
+		if ("query" in options) throw new Error("Collections cannot hold query-backed reference lists");
+		return contentFieldBuilder.referenceList(collection, options);
+	}
+};
+/** Runs a block's builders so the rest of its definition works with plain schemas. */
+function resolveBlockFields(options) {
+	const content = options.content(contentFieldBuilder);
+	const settings = options.settings?.(settingBuilder);
+	const owner = `Block "${options.id}"`;
+	assertFieldKinds(content, "content", owner);
+	if (settings) assertFieldKinds(settings, "settings", owner);
+	attachArtifactData(content, settings, owner);
+	return {
+		content,
+		settings
+	};
+}
 
 //#endregion
-export { Type$1 as Type, resolveToMarkdown };
+export { ARTIFACT_MAX_LENGTH, Conditional, FieldToken, assertFieldKinds, collectionField, collectionFieldBuilder, contentFieldBuilder, getImagePlaceholderTitle, isImagePlaceholder, resolveBlockFields, resolveToMarkdown, settingBuilder };

package/dist/core/lib/fieldTypes.js

@@ -1,10 +1,14 @@
 //#region src/core/lib/fieldTypes.tsx
 const fieldTypesDictionary = {
+	Reference: { hasOwnView: true },
+	ReferenceList: { hasOwnView: true },
+	Icon: { hasOwnView: true },
 	String: { hasOwnView: true },
 	Repeater: { hasOwnView: true },
 	Enum: { hasOwnView: true },
 	Boolean: { hasOwnView: true },
 	Embed: { hasOwnView: true },
+	Artifact: { hasOwnView: true },
 	Link: { hasOwnView: true },
 	Image: { hasOwnView: true },
 	File: { hasOwnView: true },

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

@@ -0,0 +1,13 @@
+//#region src/core/lib/iconTypes.d.ts
+declare global {
+  interface CamoxIconRegistry {}
+}
+export type IconId = CamoxIconRegistry extends {
+  ids: infer IDs extends string;
+} ? IDs : never;
+declare const iconBrand: unique symbol;
+export type IconValue = string & {
+  readonly [iconBrand]: true;
+};
+//#endregion
+export {};

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

@@ -0,0 +1,6 @@
+import { SVGProps } from "react";
+import "@camox/api-contract";
+import { QueryClient } from "@tanstack/react-query";
+//#region src/core/lib/icons.d.ts
+export type IconProps = Omit<SVGProps<SVGSVGElement>, "children" | "dangerouslySetInnerHTML" | "name">;
+//#endregion

package/dist/core/lib/icons.js

@@ -0,0 +1,126 @@
+import { c } from "react/compiler-runtime";
+import { useId } from "react";
+import { ICON_CATALOG_VERSION, scopeIconSvgIds } from "@camox/api-contract";
+import { jsx } from "react/jsx-runtime";
+import { useQuery } from "@tanstack/react-query";
+
+//#region src/core/lib/icons.tsx
+const iconQuery = (id) => ({
+	queryKey: [
+		"camox-icon",
+		ICON_CATALOG_VERSION,
+		id
+	],
+	staleTime: Infinity,
+	queryFn: async () => {
+		if (!/^[a-z0-9-]+:[a-z0-9-]+$/.test(id)) throw new Error("Invalid icon ID");
+		const response = await fetch(`${__CAMOX_API_URL__}/icons/${ICON_CATALOG_VERSION}/${id.replace(":", "/")}`);
+		if (!response.ok) throw new Error(`Unable to resolve icon ${id}`);
+		return response.json();
+	}
+});
+function IconSvg(t0) {
+	const $ = c(21);
+	let iconId;
+	let props;
+	if ($[0] !== t0) {
+		({iconId, ...props} = t0);
+		$[0] = t0;
+		$[1] = iconId;
+		$[2] = props;
+	} else {
+		iconId = $[1];
+		props = $[2];
+	}
+	let t1;
+	if ($[3] !== iconId) {
+		t1 = iconQuery(iconId);
+		$[3] = iconId;
+		$[4] = t1;
+	} else t1 = $[4];
+	const { data } = useQuery(t1);
+	const t2 = useId();
+	let t3;
+	if ($[5] !== t2) {
+		let t4;
+		if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+			t4 = /[^a-zA-Z0-9_-]/g;
+			$[7] = t4;
+		} else t4 = $[7];
+		t3 = t2.replace(t4, "");
+		$[5] = t2;
+		$[6] = t3;
+	} else t3 = $[6];
+	const instance = t3;
+	const t4 = data?.body ?? "";
+	const t5 = `camox-${instance}-`;
+	let t6;
+	if ($[8] !== t4 || $[9] !== t5) {
+		t6 = scopeIconSvgIds(t4, t5);
+		$[8] = t4;
+		$[9] = t5;
+		$[10] = t6;
+	} else t6 = $[10];
+	const body = t6;
+	const labeled = !!(props["aria-label"] || props["aria-labelledby"]);
+	const t7 = data?.attributes;
+	const t8 = labeled ? void 0 : true;
+	const t9 = labeled ? "img" : void 0;
+	const t10 = data?.attribution?.url ?? data?.attribution?.license;
+	const t11 = data?.attribution?.author;
+	let t12;
+	if ($[11] !== body) {
+		t12 = { __html: body };
+		$[11] = body;
+		$[12] = t12;
+	} else t12 = $[12];
+	let t13;
+	if ($[13] !== props || $[14] !== t10 || $[15] !== t11 || $[16] !== t12 || $[17] !== t7 || $[18] !== t8 || $[19] !== t9) {
+		t13 = /* @__PURE__ */ jsx("svg", {
+			...t7,
+			"aria-hidden": t8,
+			role: t9,
+			focusable: "false",
+			"data-icon-license": t10,
+			"data-icon-author": t11,
+			...props,
+			dangerouslySetInnerHTML: t12
+		});
+		$[13] = props;
+		$[14] = t10;
+		$[15] = t11;
+		$[16] = t12;
+		$[17] = t7;
+		$[18] = t8;
+		$[19] = t9;
+		$[20] = t13;
+	} else t13 = $[20];
+	return t13;
+}
+async function prefetchIcons(client, ...sources) {
+	const ids = /* @__PURE__ */ new Set();
+	const allowed = /* @__PURE__ */ new Set();
+	const collectSchemas = (value) => {
+		if (!value || typeof value !== "object") return;
+		const schema = value;
+		if (schema.fieldType === "Icon" && Array.isArray(schema.enum)) {
+			for (const id of schema.enum) if (typeof id === "string") allowed.add(id);
+			return;
+		}
+		Object.values(value).forEach(collectSchemas);
+	};
+	sources.forEach(collectSchemas);
+	const walk = (value) => {
+		if (!value || typeof value !== "object") return;
+		for (const [key, child] of Object.entries(value)) {
+			if (key === "enum") continue;
+			if (typeof child === "string" && allowed.has(child)) ids.add(child);
+			else walk(child);
+		}
+	};
+	sources.forEach(walk);
+	await Promise.all([...ids].map((id) => client.fetchQuery(iconQuery(id))));
+}
+
+//#endregion
+export { IconSvg, iconQuery, prefetchIcons };