kizlo 0.7.0 → 0.8.1

package/dist/menu/index.js

@@ -2,7 +2,7 @@ import { createProcedure } from "../shared/procedure.js";
 import { deserializeListMetadata } from "../shared/serialize.js";
 import { LIST_MENU_ITEM_ERROR_MAP } from "./errors.js";
 import { ListMenuInput, MenuGroupItemList, MenuItemList } from "./schema.js";
-import { buildMenuGroupItem, deserializeListMenuInput, extractSlugFromUrl } from "./utils.js";
+import { buildMenuGroupItem, deserializeListMenuInput, extractPath } from "./utils.js";
 import { stringifiedMetaRecord } from "@kizlo/shared";
 
 //#region src/menu/index.ts
@@ -15,7 +15,7 @@ const MENU_ROUTER_MAP = { items: {
 		query: ListMenuInput.optional(),
 		errors: LIST_MENU_ITEM_ERROR_MAP
 	}, async ({ context, errors, input }) => {
-		const response = await context.service.wordpress.menus.items.list(deserializeListMenuInput(input.query));
+		const response = await context.wordpress.menus.items.list(deserializeListMenuInput(input.query));
 		if (response.error) switch (response.error.code) {
 			case "rest_post_invalid_page_number": throw errors.MENU_ITEM_INVALID_PAGE();
 			case "rest_cannot_view": throw errors.MENU_ITEM_FORBIDDEN();
@@ -24,17 +24,22 @@ const MENU_ROUTER_MAP = { items: {
 				throw errors.INTERNAL_SERVER_ERROR();
 		}
 		return {
-			items: response.data.items.map((item) => {
-				const href = item.object !== "custom" ? extractSlugFromUrl(item.url) : item.url;
-				return {
-					id: item.id,
-					href,
-					name: item.title.rendered,
-					description: item.description,
-					type: item.object,
-					meta: stringifiedMetaRecord(item.meta ?? {})
-				};
-			}),
+			items: response.data.items.map((item) => ({
+				id: item.id,
+				parent: item.parent === 0 ? null : item.parent,
+				type: item.object,
+				objectId: item.object_id,
+				href: extractPath(item.url, item.object === "custom"),
+				name: item.title.rendered,
+				description: item.description,
+				target: item.target,
+				classes: item.classes.filter(Boolean),
+				attrTitle: item.attr_title,
+				xfn: item.xfn.filter(Boolean),
+				order: item.menu_order,
+				invalid: item.invalid,
+				meta: stringifiedMetaRecord(item.meta ?? {})
+			})),
 			meta: deserializeListMetadata(response.data.meta)
 		};
 	}),
@@ -46,7 +51,7 @@ const MENU_ROUTER_MAP = { items: {
 		errors: LIST_MENU_ITEM_ERROR_MAP,
 		output: MenuGroupItemList
 	}, async ({ context, errors, input }) => {
-		const response = await context.service.wordpress.menus.items.list(deserializeListMenuInput(input.query));
+		const response = await context.wordpress.menus.items.list(deserializeListMenuInput(input.query));
 		if (response.error) switch (response.error.code) {
 			case "rest_post_invalid_page_number": throw errors.MENU_ITEM_INVALID_PAGE();
 			case "rest_cannot_view": throw errors.MENU_ITEM_FORBIDDEN();

package/dist/menu/schema.d.ts

@@ -0,0 +1,14 @@
+import { LiteralUnion, Metadata } from "@kizlo/shared";
+import z from "zod/v4";
+
+//#region src/menu/schema.d.ts
+declare const MENU_TYPES: readonly ["page", "post", "category", "tag", "product", "product_cat", "product_tag", "custom"];
+type MenuType = LiteralUnion<(typeof MENU_TYPES)[number], string>;
+declare const MenuType: z.ZodType<MenuType>;
+declare const MenuTarget: z.ZodEnum<{
+  "": "";
+  _blank: "_blank";
+}>;
+type MenuTarget = z.infer<typeof MenuTarget>;
+//#endregion
+export { MenuTarget, MenuType };

package/dist/menu/schema.js

@@ -1,24 +1,25 @@
 import { ListMetadata, ListOrder } from "../shared/schema.js";
-import { Metadata, NumberLike, arrayable } from "@kizlo/shared";
+import { WP_MENU_ITEM_ORDER_BYES, WP_MENU_ITEM_TARGETS, WP_MENU_ITEM_TAX_RELATIONS } from "../wordpress/menu/items/types.js";
+import { Metadata, NumberLike, arrayable, lenient } from "@kizlo/shared";
 import z from "zod/v4";
 
 //#region src/menu/schema.ts
-const MENU_TYPES = [
-	"page",
-	"post",
-	"category",
-	"product",
-	"product_cat",
-	"product_tag",
-	"custom"
-];
-const MenuType = z.enum(MENU_TYPES);
+const MenuType = z.string();
+const MenuTarget = z.enum(WP_MENU_ITEM_TARGETS);
 const MenuItem = z.object({
 	id: z.number(),
+	parent: z.number().nullable(),
+	type: MenuType,
+	objectId: z.number(),
 	href: z.string(),
 	name: z.string(),
-	type: MenuType,
 	description: z.string(),
+	target: MenuTarget,
+	classes: z.array(z.string()),
+	attrTitle: z.string(),
+	xfn: z.array(z.string()),
+	order: z.number(),
+	invalid: z.boolean(),
 	meta: Metadata
 });
 const MenuGroupItem = z.lazy(() => MenuItem.extend({
@@ -34,36 +35,30 @@ const MenuGroupItemList = z.object({
 	items: z.array(MenuGroupItem),
 	meta: ListMetadata
 });
-const MENU_ITEM_ORDER_BYES = [
-	"author",
-	"date",
-	"id",
-	"include",
-	"parent",
-	"relevance",
-	"slug",
-	"include_slugs",
-	"title",
-	"menu_order"
+const MenuItemOrderBy = z.enum(WP_MENU_ITEM_ORDER_BYES).exclude(["modified"]);
+const MENU_ITEM_SEARCH_COLUMNS = [
+	"post_title",
+	"post_content",
+	"post_excerpt"
 ];
-const MenuItemOrderBy = z.enum(MENU_ITEM_ORDER_BYES);
+const MenuItemSearchColumn = z.enum(MENU_ITEM_SEARCH_COLUMNS);
 const ListMenuInput = z.object({
-	page: NumberLike.optional(),
-	perPage: NumberLike.optional(),
-	search: z.string().optional(),
-	after: z.string().optional(),
-	before: z.string().optional(),
-	exclude: arrayable(NumberLike).optional(),
-	include: arrayable(NumberLike).optional(),
-	offset: NumberLike.optional(),
-	order: ListOrder.optional(),
-	orderby: MenuItemOrderBy.optional(),
-	searchColumns: z.array(z.string()).optional(),
-	slug: arrayable(z.string()).optional(),
-	taxRelation: z.enum(["AND", "OR"]).optional(),
-	menus: arrayable(NumberLike).optional(),
-	menusExclude: arrayable(NumberLike).optional(),
-	menuOrder: NumberLike.optional()
+	page: NumberLike.pipe(z.number().int().min(1)).catch(1).optional(),
+	perPage: lenient(NumberLike.pipe(z.number().int().min(1).max(100))),
+	search: lenient(z.string()),
+	after: lenient(z.string()),
+	before: lenient(z.string()),
+	exclude: lenient(arrayable(NumberLike)),
+	include: lenient(arrayable(NumberLike)),
+	offset: lenient(NumberLike.pipe(z.number().int().min(0))),
+	order: lenient(ListOrder),
+	orderby: lenient(MenuItemOrderBy),
+	searchColumns: lenient(z.array(MenuItemSearchColumn)),
+	slug: lenient(arrayable(z.string())),
+	taxRelation: lenient(z.enum(WP_MENU_ITEM_TAX_RELATIONS)),
+	menus: lenient(arrayable(NumberLike)),
+	menusExclude: lenient(arrayable(NumberLike)),
+	menuOrder: lenient(NumberLike.pipe(z.number().int()))
 });
 
 //#endregion

package/dist/menu/utils.js

@@ -2,6 +2,7 @@ import { stringifiedMetaRecord } from "@kizlo/shared";
 
 //#region src/menu/utils.ts
 function deserializeListMenuInput(input) {
+	const orderby = input?.orderby === "relevance" && !input?.search || input?.orderby === "include" && input?.include === void 0 || input?.orderby === "include_slugs" && input?.slug === void 0 ? void 0 : input?.orderby;
 	return {
 		context: "edit",
 		after: input?.after,
@@ -13,7 +14,7 @@ function deserializeListMenuInput(input) {
 		menus_exclude: input?.menusExclude,
 		offset: input?.offset,
 		order: input?.order,
-		orderby: input?.orderby,
+		orderby,
 		page: input?.page,
 		per_page: input?.perPage,
 		search: input?.search,
@@ -23,30 +24,38 @@ function deserializeListMenuInput(input) {
 		status: "publish"
 	};
 }
-function extractSlugFromUrl(url) {
+/**
+* The `href` a headless frontend links to. WP builds a non-custom item's `url` as an absolute same-site
+* URL, so we return its full pathname; a custom item's `url` is passed through as authored (a relative
+* path, or an absolute URL for external links). Both yield the same value for the same internal path.
+*/
+function extractPath(url, isCustom) {
 	if (!url || url.trim() === "") return "/";
 	const trimmed = url.trim();
-	let pathname;
+	if (isCustom) return trimmed;
 	if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) try {
-		pathname = new URL(trimmed).pathname;
+		return new URL(trimmed).pathname || "/";
 	} catch {
-		pathname = trimmed;
+		return trimmed;
 	}
-	else pathname = trimmed;
-	const cleanPath = pathname.replace(/^\/+|\/+$/g, "");
-	if (!cleanPath) return "/";
-	const segments = cleanPath.split("/");
-	return segments[segments.length - 1] ?? "/";
+	return trimmed;
 }
 function buildMenuGroupItem(wpItem, items) {
 	const children = items.filter((item) => item.parent === wpItem.id).sort((a, b) => a.menu_order - b.menu_order).map((child) => buildMenuGroupItem(child, items));
-	const href = wpItem.object !== "custom" ? extractSlugFromUrl(wpItem.url) : wpItem.url;
 	return {
 		id: wpItem.id,
-		href,
+		parent: wpItem.parent === 0 ? null : wpItem.parent,
+		type: wpItem.object,
+		objectId: wpItem.object_id,
+		href: extractPath(wpItem.url, wpItem.object === "custom"),
 		name: wpItem.title.rendered,
 		description: wpItem.description,
-		type: wpItem.object,
+		target: wpItem.target,
+		classes: wpItem.classes.filter(Boolean),
+		attrTitle: wpItem.attr_title,
+		xfn: wpItem.xfn.filter(Boolean),
+		order: wpItem.menu_order,
+		invalid: wpItem.invalid,
 		items: children,
 		hasItems: children.length > 0,
 		meta: stringifiedMetaRecord(wpItem.meta ?? {})
@@ -54,4 +63,4 @@ function buildMenuGroupItem(wpItem, items) {
 }
 
 //#endregion
-export { buildMenuGroupItem, deserializeListMenuInput, extractSlugFromUrl };
+export { buildMenuGroupItem, deserializeListMenuInput, extractPath };

package/dist/nextjs/server.d.ts

@@ -1,4 +1,5 @@
 import { WEB_MANIFEST_ROUTE } from "../brand/manifest.js";
+import { createSitemapRedirectRoute } from "../seo/sitemap.js";
 import { NextRevalidateOptions, RevalidatePathFn, RevalidateTagFn, RevalidateTarget, nextRevalidation } from "../integrations/nextjs/revalidate.js";
 import { KizloServerOptions, createKizlo } from "../integrations/nextjs/kizlo.server.js";
 import { MANIFEST_CACHE_TAG, createManifestRoute } from "../integrations/nextjs/manifest.js";
@@ -6,4 +7,4 @@ import { createPageMetadata, createRootMetadata, createRootViewport } from "../i
 import { ROBOTS_CACHE_TAG, createRobotsRoute } from "../integrations/nextjs/robots.js";
 import { SITEMAP_CACHE_TAG, SITEMAP_ROUTE, createSitemapRoute } from "../integrations/nextjs/sitemap.js";
 import { createCachedTextRoute, createNextCookiesInterface, getServerBaseUrl } from "../integrations/nextjs/utils.js";
-export { KizloServerOptions, MANIFEST_CACHE_TAG, NextRevalidateOptions, ROBOTS_CACHE_TAG, RevalidatePathFn, RevalidateTagFn, RevalidateTarget, SITEMAP_CACHE_TAG, SITEMAP_ROUTE, WEB_MANIFEST_ROUTE, createCachedTextRoute, createKizlo, createManifestRoute, createNextCookiesInterface, createPageMetadata, createRobotsRoute, createRootMetadata, createRootViewport, createSitemapRoute, getServerBaseUrl, nextRevalidation };
+export { KizloServerOptions, MANIFEST_CACHE_TAG, NextRevalidateOptions, ROBOTS_CACHE_TAG, RevalidatePathFn, RevalidateTagFn, RevalidateTarget, SITEMAP_CACHE_TAG, SITEMAP_ROUTE, WEB_MANIFEST_ROUTE, createCachedTextRoute, createKizlo, createManifestRoute, createNextCookiesInterface, createPageMetadata, createRobotsRoute, createRootMetadata, createRootViewport, createSitemapRedirectRoute, createSitemapRoute, getServerBaseUrl, nextRevalidation };

package/dist/nextjs/server.js

@@ -1,4 +1,5 @@
 import { WEB_MANIFEST_ROUTE } from "../brand/manifest.js";
+import { createSitemapRedirectRoute } from "../seo/sitemap.js";
 import { createCachedTextRoute, createNextCookiesInterface, getServerBaseUrl } from "../integrations/nextjs/utils.js";
 import { ROBOTS_CACHE_TAG, createRobotsRoute } from "../integrations/nextjs/robots.js";
 import { SITEMAP_CACHE_TAG, SITEMAP_ROUTE, createSitemapRoute } from "../integrations/nextjs/sitemap.js";
@@ -7,4 +8,4 @@ import { createKizlo } from "../integrations/nextjs/kizlo.server.js";
 import { MANIFEST_CACHE_TAG, createManifestRoute } from "../integrations/nextjs/manifest.js";
 import { createPageMetadata, createRootMetadata, createRootViewport } from "../integrations/nextjs/metadata.js";
 
-export { MANIFEST_CACHE_TAG, ROBOTS_CACHE_TAG, SITEMAP_CACHE_TAG, SITEMAP_ROUTE, WEB_MANIFEST_ROUTE, createCachedTextRoute, createKizlo, createManifestRoute, createNextCookiesInterface, createPageMetadata, createRobotsRoute, createRootMetadata, createRootViewport, createSitemapRoute, getServerBaseUrl, nextRevalidation };
+export { MANIFEST_CACHE_TAG, ROBOTS_CACHE_TAG, SITEMAP_CACHE_TAG, SITEMAP_ROUTE, WEB_MANIFEST_ROUTE, createCachedTextRoute, createKizlo, createManifestRoute, createNextCookiesInterface, createPageMetadata, createRobotsRoute, createRootMetadata, createRootViewport, createSitemapRedirectRoute, createSitemapRoute, getServerBaseUrl, nextRevalidation };

package/dist/package.js

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "0.7.0";
+var version = "0.8.1";
 
 //#endregion
 export { version };

package/dist/page/error.js

@@ -0,0 +1,20 @@
+import { defineErrorMap } from "../shared/error.js";
+
+//#region src/page/error.ts
+const GET_PAGE_ERROR_MAP = defineErrorMap({
+	PAGE_NOT_FOUND: {
+		status: 404,
+		message: "Page not found"
+	},
+	PAGE_PASSWORD_INVALID: {
+		status: 400,
+		message: "Invalid page password."
+	}
+});
+const LIST_PAGE_ERROR_MAP = defineErrorMap({ PAGE_INVALID_PAGE: {
+	status: 400,
+	message: "The requested page does not exist."
+} });
+
+//#endregion
+export { GET_PAGE_ERROR_MAP, LIST_PAGE_ERROR_MAP };

package/dist/page/index.js

@@ -0,0 +1,128 @@
+import { compare } from "../shared/crypto.js";
+import { createProcedure } from "../shared/procedure.js";
+import { parseIdentifier } from "../shared/identifier.js";
+import { deserializeListMetadata } from "../shared/serialize.js";
+import { getPostTypeService } from "../post-type/service.js";
+import { GET_PAGE_ERROR_MAP, LIST_PAGE_ERROR_MAP } from "./error.js";
+import { ListPageInput, Page, PageList, RetrievePageInput } from "./schema.js";
+import { deserializePage } from "./utils.js";
+
+//#region src/page/index.ts
+const PAGE_ROUTER_MAP = {
+	get: createProcedure({
+		scope: "api",
+		method: "GET",
+		path: "/pages/{identifier}",
+		params: RetrievePageInput.pick({ identifier: true }),
+		query: RetrievePageInput.pick({
+			password: true,
+			previewToken: true
+		}).optional(),
+		output: Page,
+		errors: GET_PAGE_ERROR_MAP
+	}, async ({ input, context, errors }) => {
+		const postType = getPostTypeService("page", context.wordpress);
+		if (input.query?.previewToken) {
+			const result = await context.verifyPreviewToken(input.query.previewToken);
+			if (!result) throw errors.PAGE_NOT_FOUND();
+			const response$1 = await postType.get({
+				type: "id",
+				value: result.id
+			});
+			if (response$1.error) switch (response$1.error.code) {
+				case "invalid_post_type":
+				case "post_type_not_found":
+				case "rest_post_invalid_id": throw errors.PAGE_NOT_FOUND();
+				case "rest_post_incorrect_password": throw errors.PAGE_PASSWORD_INVALID();
+				default:
+					context.logger.error("Get page preview unhandled error", response$1.error, {
+						id: result.id,
+						code: response$1.error.code
+					});
+					throw errors.INTERNAL_SERVER_ERROR();
+			}
+			return deserializePage({
+				...response$1.data,
+				password: ""
+			}, { preview: true });
+		}
+		const identifier = parseIdentifier(input.params.identifier);
+		if (!identifier) throw errors.PAGE_NOT_FOUND();
+		const response = await postType.get(identifier);
+		if (response.error) switch (response.error.code) {
+			case "invalid_post_type":
+			case "post_type_not_found":
+			case "rest_post_invalid_id": throw errors.PAGE_NOT_FOUND();
+			case "rest_post_incorrect_password": throw errors.PAGE_PASSWORD_INVALID();
+			default:
+				context.logger.error("Get page unhandled error", response.error, {
+					identifier,
+					code: response.error.code
+				});
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		const data = response.data;
+		if (data.status !== "publish") throw errors.PAGE_NOT_FOUND();
+		if (input.query?.password && data.password) {
+			if (!await compare(input.query.password, data.password)) throw errors.PAGE_PASSWORD_INVALID();
+			return deserializePage({
+				...data,
+				password: ""
+			});
+		}
+		return deserializePage(data);
+	}),
+	list: createProcedure({
+		scope: "api",
+		method: "GET",
+		path: "/pages",
+		query: ListPageInput.optional(),
+		output: PageList,
+		errors: LIST_PAGE_ERROR_MAP
+	}, async ({ input, context, errors }) => {
+		const q = input.query;
+		const postType = getPostTypeService("page", context.wordpress);
+		const orderby = q?.orderby === "relevance" && !q?.search || q?.orderby === "include" && q?.include === void 0 ? void 0 : q?.orderby;
+		const response = await postType.list({
+			context: "edit",
+			status: "publish",
+			after: input.query?.after,
+			author: input.query?.author,
+			author_exclude: input.query?.authorExclude,
+			before: input.query?.before,
+			modified_after: input.query?.modifiedAfter,
+			modified_before: input.query?.modifiedBefore,
+			exclude: input.query?.exclude,
+			include: input.query?.include,
+			menu_order: input.query?.menuOrder,
+			offset: input.query?.offset,
+			order: input.query?.order,
+			orderby,
+			page: input.query?.page,
+			parent: input.query?.parent,
+			parent_exclude: input.query?.parentExclude,
+			per_page: input.query?.perPage,
+			search: input.query?.search,
+			search_columns: input.query?.searchColumns,
+			slug: input.query?.slug
+		});
+		if (response.error) switch (response.error.code) {
+			case "rest_post_invalid_page_number": throw errors.PAGE_INVALID_PAGE();
+			default:
+				context.logger.error("List pages unhandled error", response.error, { code: response.error.code });
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		const list = context.wordpress.resolveList({
+			data: response.data,
+			headers: response.headers,
+			searchParams: input.query
+		});
+		return {
+			meta: deserializeListMetadata(list.meta),
+			items: list.items.map((item) => deserializePage(item))
+		};
+	})
+};
+
+//#endregion
+export { PAGE_ROUTER_MAP };

package/dist/page/schema.js

@@ -0,0 +1,75 @@
+import { IdentifierInput, ListMetadata, ListOrder, Media } from "../shared/schema.js";
+import { WP_PAGE_ORDER_BYES, WP_PAGE_STATUSES } from "../wordpress/page/types.js";
+import { Seo } from "../seo/schema.js";
+import { Metadata, NumberLike, arrayable, lenient } from "@kizlo/shared";
+import z from "zod/v4";
+
+//#region src/page/schema.ts
+const PageStatus = z.enum(WP_PAGE_STATUSES).exclude(["trash"]);
+const PageAuthorRef = z.object({
+	id: z.number(),
+	name: z.string(),
+	slug: z.string(),
+	avatar: Media.nullable()
+});
+const Page = z.object({
+	id: z.number(),
+	slug: z.string(),
+	url: z.string().nullable(),
+	parent: z.number().nullable(),
+	menuOrder: z.number(),
+	template: z.string(),
+	title: z.string().nullable(),
+	content: z.string().nullable(),
+	excerpt: z.string().nullable(),
+	commentsEnabled: z.boolean(),
+	protected: z.boolean(),
+	preview: z.boolean(),
+	status: PageStatus,
+	author: PageAuthorRef.nullable(),
+	featuredMedia: Media.nullable(),
+	seo: Seo.nullable(),
+	createdAt: z.number(),
+	updatedAt: z.number(),
+	meta: Metadata
+});
+const RetrievePageInput = z.object({
+	identifier: IdentifierInput,
+	password: z.string().optional(),
+	previewToken: z.string().optional()
+});
+const PageList = z.object({
+	items: z.array(Page),
+	meta: ListMetadata
+});
+const PageOrderBy = z.enum(WP_PAGE_ORDER_BYES);
+const PAGE_SEARCH_COLUMNS = [
+	"post_title",
+	"post_content",
+	"post_excerpt"
+];
+const PageSearchColumn = z.enum(PAGE_SEARCH_COLUMNS);
+const ListPageInput = z.object({
+	page: NumberLike.pipe(z.number().int().min(1)).catch(1).optional(),
+	perPage: lenient(NumberLike.pipe(z.number().int().min(1).max(100))),
+	search: lenient(z.string()),
+	after: lenient(z.string()),
+	before: lenient(z.string()),
+	modifiedAfter: lenient(z.string()),
+	modifiedBefore: lenient(z.string()),
+	author: lenient(arrayable(NumberLike)),
+	authorExclude: lenient(arrayable(NumberLike)),
+	exclude: lenient(arrayable(NumberLike)),
+	include: lenient(arrayable(NumberLike)),
+	offset: lenient(NumberLike.pipe(z.number().int().min(0))),
+	order: lenient(ListOrder),
+	orderby: lenient(PageOrderBy),
+	searchColumns: lenient(z.array(PageSearchColumn)),
+	slug: lenient(arrayable(z.string())),
+	parent: lenient(arrayable(NumberLike)),
+	parentExclude: lenient(arrayable(NumberLike)),
+	menuOrder: lenient(NumberLike)
+});
+
+//#endregion
+export { ListPageInput, Page, PageList, RetrievePageInput };

package/dist/page/utils.js

@@ -0,0 +1,43 @@
+import { deserializeSeo } from "../seo/utils.js";
+import { resolveWpTimestamp, stringifiedMetaRecord } from "@kizlo/shared";
+
+//#region src/page/utils.ts
+function deserializePage(data, options) {
+	const locked = data.password.length > 0;
+	const kizlo = data.kizlo;
+	const title = data.title.rendered;
+	return {
+		id: data.id,
+		url: kizlo.url ?? null,
+		parent: data.parent || null,
+		menuOrder: data.menu_order ?? 0,
+		template: data.template ?? "",
+		title: title.length > 0 ? title : null,
+		content: locked ? null : data.content?.rendered ?? null,
+		excerpt: locked ? null : data.excerpt?.rendered ?? null,
+		protected: locked,
+		preview: options?.preview ?? false,
+		status: data.status === "trash" ? "draft" : data.status,
+		featuredMedia: kizlo.featured_media ?? null,
+		commentsEnabled: data.comment_status === "open",
+		slug: data.slug,
+		author: kizlo.author ? {
+			id: kizlo.author.id,
+			name: kizlo.author.name,
+			slug: kizlo.author.slug,
+			avatar: kizlo.author.avatar_url ? {
+				id: 0,
+				alt: kizlo.author.name,
+				name: kizlo.author.name,
+				src: kizlo.author.avatar_url
+			} : null
+		} : null,
+		seo: kizlo.seo ? deserializeSeo(kizlo.seo) : null,
+		createdAt: resolveWpTimestamp(data.date_gmt) ?? resolveWpTimestamp(data.modified_gmt) ?? 0,
+		updatedAt: resolveWpTimestamp(data.modified_gmt) ?? 0,
+		meta: stringifiedMetaRecord(data.meta ?? {})
+	};
+}
+
+//#endregion
+export { deserializePage };

package/dist/post/error.js

@@ -11,20 +11,10 @@ const GET_POST_ERROR_MAP = defineErrorMap({
 		message: "Invalid post password."
 	}
 });
-const LIST_POST_ERROR_MAP = defineErrorMap({
-	POST_INVALID_PAGE: {
-		status: 400,
-		message: "The requested page does not exist."
-	},
-	POST_SEARCH_REQUIRED: {
-		status: 400,
-		message: "A search term is required."
-	},
-	POST_ORDERBY_INCLUDE_MISSING: {
-		status: 400,
-		message: "Ordering by 'include' requires the include parameter."
-	}
-});
+const LIST_POST_ERROR_MAP = defineErrorMap({ POST_INVALID_PAGE: {
+	status: 400,
+	message: "The requested page does not exist."
+} });
 
 //#endregion
 export { GET_POST_ERROR_MAP, LIST_POST_ERROR_MAP };