camox 0.44.0 → 0.46.0

package/dist/core/createApp.js

@@ -1,8 +1,59 @@
+import { artifactFontLinks } from "./lib/artifact.js";
+
 //#region src/core/createApp.ts
-function createApp({ blocks, layouts = [] }) {
+function createApp({ blocks, lazyBlocks = {}, layouts = [], collections = [], document }) {
 	const blocksMap = /* @__PURE__ */ new Map();
 	const layoutsMap = /* @__PURE__ */ new Map();
+	const collectionsMap = /* @__PURE__ */ new Map();
+	for (const collection of collections) {
+		const id = collection._internal.id;
+		if (collectionsMap.has(id)) throw new Error(`Duplicate collection: ${id}`);
+		collectionsMap.set(id, collection);
+	}
 	for (const block of blocks) blocksMap.set(block._internal.id, block);
+	const lazyBlockLoads = /* @__PURE__ */ new Map();
+	const loadLazyBlock = (key) => {
+		let load = lazyBlockLoads.get(key);
+		if (!load) {
+			load = lazyBlocks[key]().then((block) => {
+				if (block) blocksMap.set(block._internal.id, block);
+				return block;
+			});
+			lazyBlockLoads.set(key, load);
+			load.catch(() => lazyBlockLoads.delete(key));
+		}
+		return load;
+	};
+	let allBlocksLoaded = Object.keys(lazyBlocks).length === 0;
+	let allBlocksLoad;
+	const loadAllBlocks = () => {
+		if (!allBlocksLoad) {
+			allBlocksLoad = Promise.all(Object.keys(lazyBlocks).map(loadLazyBlock)).then(() => {
+				allBlocksLoaded = true;
+			});
+			allBlocksLoad.catch(() => allBlocksLoad = void 0);
+		}
+		return allBlocksLoad;
+	};
+	const blockLoads = /* @__PURE__ */ new Map();
+	const loadBlock = (id) => {
+		let load = blockLoads.get(id);
+		if (!load) {
+			load = (async () => {
+				const loaded = blocksMap.get(id);
+				if (loaded) return loaded;
+				if (Object.hasOwn(lazyBlocks, id)) {
+					const block = await loadLazyBlock(id);
+					if (block?._internal.id === id) return block;
+				}
+				await loadAllBlocks();
+				return blocksMap.get(id);
+			})();
+			blockLoads.set(id, load);
+			load.catch(() => blockLoads.delete(id));
+		}
+		return load;
+	};
 	const derivedPatterns = /* @__PURE__ */ new Set();
 	for (const layout of layouts) {
 		const { id, kind } = layout._internal;
@@ -14,56 +65,99 @@ function createApp({ blocks, layouts = [] }) {
 		}
 		layoutsMap.set(id, layout);
 	}
-	const layoutsWithInitialBlocks = layouts.filter((l) => l._internal.initialBlockBundles);
+	const layoutsWithInitialBlocks = layouts.filter((l) => l._internal.loadInitialBlockBundles);
 	if (layoutsWithInitialBlocks.length > 1) {
 		const ids = layoutsWithInitialBlocks.map((l) => `"${l._internal.id}"`).join(", ");
 		throw new Error(`[camox] Only one layout can define blocks.initial, but found ${layoutsWithInitialBlocks.length}: ${ids}`);
 	}
+	const fontLinks = artifactFontLinks(document);
+	/** Loads the initial blocks' modules: only syncing needs them, never a page. */
+	const getHomepage = async () => {
+		const layout = layoutsWithInitialBlocks[0];
+		if (layout) return {
+			layoutId: layout._internal.id,
+			blocks: await layout._internal.loadInitialBlockBundles(),
+			hasInitialBlocks: true
+		};
+		const fallback = layouts.find((layout) => layout._internal.kind === "curated");
+		if (!fallback) return null;
+		return {
+			layoutId: fallback._internal.id,
+			blocks: [],
+			hasInitialBlocks: false
+		};
+	};
 	return {
+		/** The document's font links as HTML, for artifacts to load before their source. */
+		getArtifactFontLinks() {
+			return fontLinks;
+		},
+		getCollections() {
+			return Array.from(collectionsMap.values());
+		},
+		getCollectionById(id) {
+			return collectionsMap.get(id);
+		},
+		/** The loaded blocks: every block after `loadAllBlocks`. */
 		getBlocks() {
 			return Array.from(blocksMap.values());
 		},
+		/** A loaded block. Call `loadBlock` first for a block that may be lazy. */
 		getBlockById(id) {
 			return blocksMap.get(id);
 		},
+		loadBlock,
+		/** Whether a block not loaded yet could still load, rather than not exist. */
+		canLoadMoreBlocks() {
+			return !allBlocksLoaded;
+		},
+		async loadBlocks(ids) {
+			await Promise.all([...new Set(ids)].map(loadBlock));
+		},
+		/** Every block definition, which editing needs, rather than only a page's. */
+		loadAllBlocks,
 		getLayouts() {
 			return Array.from(layoutsMap.values());
 		},
 		getLayoutById(id) {
 			return layoutsMap.get(id);
 		},
-		getSerializableDefinitions() {
-			return Array.from(blocksMap.values()).map((block) => ({
-				blockId: block._internal.id,
-				title: block._internal.title,
-				description: block._internal.description,
-				contentSchema: block._internal.contentSchema,
-				settingsSchema: block._internal.settingsSchema,
-				layoutOnly: block._internal.layoutOnly || void 0,
-				synced: block._internal.synced
-			}));
-		},
-		getSerializableLayoutDefinitions() {
-			return Array.from(layoutsMap.values()).map((layout) => ({
+		/**
+		* The website's Definition Set: every block (lazy ones included, layout-only ones only when a
+		* layout declares them), layout and collection definition, and the homepage they declare.
+		* Never calls the network; the API computes schema hashes on write.
+		*/
+		async getDefinitionSet() {
+			await loadAllBlocks();
+			const layoutDefinitions = Array.from(layoutsMap.values()).map((layout) => ({
 				layoutId: layout._internal.id,
 				kind: layout._internal.kind,
 				description: layout._internal.description,
-				blocks: layout._internal.blockDefinitions
+				blocks: layout._internal.blockDefinitions,
+				...layout._internal.recordPages && { recordPages: layout._internal.recordPages }
 			}));
-		},
-		getInitialPageBundles() {
-			const layout = layoutsWithInitialBlocks[0];
-			if (layout) return {
-				layoutId: layout._internal.id,
-				blocks: layout._internal.initialBlockBundles,
-				hasInitialBlocks: true
-			};
-			const fallback = layouts.find((layout) => layout._internal.kind === "curated");
-			if (!fallback) return null;
+			const typesUsedInLayouts = new Set(layoutDefinitions.flatMap((layout) => layout.blocks.map((block) => block.type)));
 			return {
-				layoutId: fallback._internal.id,
-				blocks: [],
-				hasInitialBlocks: false
+				blocks: Array.from(blocksMap.values()).filter((block) => !block._internal.layoutOnly || typesUsedInLayouts.has(block._internal.id)).map(({ _internal }) => ({
+					blockId: _internal.id,
+					title: _internal.title,
+					description: _internal.description,
+					contentSchema: _internal.contentSchema,
+					settingsSchema: _internal.settingsSchema,
+					defaultContent: _internal.getInitialContent(),
+					defaultSettings: _internal.getInitialSettings(),
+					layoutOnly: _internal.layoutOnly || void 0,
+					synced: _internal.synced
+				})),
+				layouts: layoutDefinitions,
+				collections: Array.from(collectionsMap.values()).map(({ _internal }) => ({
+					collectionId: _internal.id,
+					title: _internal.title,
+					description: _internal.description,
+					label: _internal.label,
+					contentSchema: JSON.parse(JSON.stringify(_internal.contentSchema))
+				})),
+				homepage: await getHomepage()
 			};
 		}
 	};

package/dist/core/createBlock.d.ts

@@ -1,10 +1,10 @@
-import { Type } from "./lib/contentType.js";
 import { InlineStyle, InlineTextStyles, TextLinkStyleData, TextStyleData } from "./lib/textStyles.js";
+import "./lib/lexicalReact.js";
+import { ContentFieldBuilder, SettingBuilder } from "./lib/contentType.js";
 import { BlockComponentProps, PeekItem, RepeatableItemSeed, createEditableBlock } from "./editing/createEditableBlock.js";
-
 //#region src/core/createBlock.d.ts
 type EditableCreateBlock = typeof createEditableBlock;
-declare const createBlock: EditableCreateBlock;
-type Block = ReturnType<typeof createBlock>;
+export declare const createBlock: EditableCreateBlock;
+export type Block = ReturnType<typeof createBlock>;
 //#endregion
-export { Block, type BlockComponentProps, type InlineStyle, type InlineTextStyles, type PeekItem, type RepeatableItemSeed, type TextLinkStyleData, type TextStyleData, Type, createBlock };
+export type { BlockComponentProps, ContentFieldBuilder, InlineStyle, InlineTextStyles, PeekItem, RepeatableItemSeed, SettingBuilder, TextLinkStyleData, TextStyleData };