@readpress/wp-blog 1.0.0

package/dist/index.js

@@ -0,0 +1,1326 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  WpClientError: () => WpClientError,
+  createWpBlogClient: () => createWpBlogClient,
+  getAuthorById: () => getAuthorById,
+  getAuthors: () => getAuthors,
+  getCategories: () => getCategories,
+  getPostById: () => getPostById,
+  getPostBySlug: () => getPostBySlug,
+  getPosts: () => getPosts,
+  getTags: () => getTags,
+  parseContentPlaceholders: () => parseContentPlaceholders,
+  queryGraphql: () => queryGraphql,
+  queryRaw: () => queryRaw,
+  searchPosts: () => searchPosts
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/errors.ts
+var WpClientError = class extends Error {
+  constructor(code, message, status, details = {}) {
+    super(message);
+    this.name = "WpClientError";
+    this.code = code;
+    this.status = status;
+    this.wpCode = details.wpCode;
+    this.wpMessage = details.wpMessage;
+    this.wpData = details.wpData;
+  }
+};
+
+// src/domain/placeholders.ts
+var DEFAULT_NAMESPACE = "wpapp";
+var DEFAULT_MAX_PROPS_LENGTH = 1e4;
+var PLACEHOLDER_NAME_REGEX = /^[A-Za-z][A-Za-z0-9_-]*$/;
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeNamespace(value) {
+  const trimmed = value == null ? void 0 : value.trim();
+  if (!trimmed) {
+    return DEFAULT_NAMESPACE;
+  }
+  return trimmed;
+}
+function normalizeMaxPropsLength(value) {
+  if (!value || !Number.isInteger(value) || value <= 0) {
+    return DEFAULT_MAX_PROPS_LENGTH;
+  }
+  return value;
+}
+function parseProps(rawProps, maxPropsLength) {
+  const trimmed = rawProps == null ? void 0 : rawProps.trim();
+  if (!trimmed) {
+    return {};
+  }
+  if (trimmed.length > maxPropsLength) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    return parsed;
+  } catch (e) {
+    return null;
+  }
+}
+function parseContentPlaceholders(contentHtml, options = {}) {
+  if (!contentHtml) {
+    return [{ type: "html", html: "" }];
+  }
+  const namespace = normalizeNamespace(options.namespace);
+  const maxPropsLength = normalizeMaxPropsLength(options.maxPropsLength);
+  const markerRegex = new RegExp(
+    `<!--\\s*${escapeRegex(namespace)}:([A-Za-z][A-Za-z0-9_-]*)(?:\\s+([\\s\\S]*?))?\\s*-->`,
+    "g"
+  );
+  const parts = [];
+  let cursor = 0;
+  let match;
+  while ((match = markerRegex.exec(contentHtml)) !== null) {
+    const [fullMatch, rawName, rawProps] = match;
+    const matchIndex = match.index;
+    if (matchIndex > cursor) {
+      parts.push({ type: "html", html: contentHtml.slice(cursor, matchIndex) });
+    }
+    const name = rawName == null ? void 0 : rawName.trim();
+    const props = parseProps(rawProps, maxPropsLength);
+    if (!name || !PLACEHOLDER_NAME_REGEX.test(name) || !props) {
+      parts.push({ type: "html", html: fullMatch });
+      cursor = markerRegex.lastIndex;
+      continue;
+    }
+    parts.push({
+      type: "placeholder",
+      name,
+      props
+    });
+    cursor = markerRegex.lastIndex;
+  }
+  if (cursor < contentHtml.length) {
+    parts.push({ type: "html", html: contentHtml.slice(cursor) });
+  }
+  if (parts.length === 0) {
+    return [{ type: "html", html: contentHtml }];
+  }
+  return parts;
+}
+
+// src/core/config.ts
+var DEFAULT_PER_PAGE = 10;
+var DEFAULT_ENDPOINT = "/wp-json/wp/v2/posts";
+function readEnv(name) {
+  var _a, _b;
+  const scopedGlobal = globalThis;
+  return (_b = (_a = scopedGlobal.process) == null ? void 0 : _a.env) == null ? void 0 : _b[name];
+}
+function normalizeWpUrl(rawUrl) {
+  const trimmed = rawUrl.trim();
+  if (!trimmed) {
+    throw new WpClientError("INVALID_CONFIG", "WP URL cannot be empty.");
+  }
+  try {
+    const url = new URL(trimmed);
+    return url.toString().replace(/\/$/, "");
+  } catch (e) {
+    throw new WpClientError("INVALID_CONFIG", `Invalid WP URL: ${rawUrl}`);
+  }
+}
+function normalizePathOrUrl(value, label) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new WpClientError("INVALID_CONFIG", `${label} cannot be empty.`);
+  }
+  if (/^https?:\/\//i.test(trimmed)) {
+    return trimmed;
+  }
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+function parseHeadersJson(raw) {
+  if (!raw) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new WpClientError("INVALID_CONFIG", "WP_AUTH_HEADERS_JSON must be valid JSON.");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new WpClientError("INVALID_CONFIG", "WP_AUTH_HEADERS_JSON must be a JSON object.");
+  }
+  const headers = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (typeof value !== "string") {
+      throw new WpClientError("INVALID_CONFIG", "WP_AUTH_HEADERS_JSON values must be strings.");
+    }
+    headers[key] = value;
+  }
+  return headers;
+}
+function resolveAuthType(config) {
+  var _a;
+  const explicitType = (_a = config.type) != null ? _a : readEnv("WP_AUTH_TYPE");
+  if (explicitType) {
+    const normalized = explicitType.toLowerCase();
+    if (normalized === "none" || normalized === "basic" || normalized === "bearer" || normalized === "headers") {
+      return normalized;
+    }
+    throw new WpClientError("INVALID_CONFIG", "WP_AUTH_TYPE must be one of: none, basic, bearer, headers.");
+  }
+  if (config.headers && Object.keys(config.headers).length > 0) {
+    return "headers";
+  }
+  if (config.token) {
+    return "bearer";
+  }
+  if (config.user || config.appPassword) {
+    return "basic";
+  }
+  return "none";
+}
+function resolveAuth(options) {
+  var _a, _b, _c, _d, _e;
+  const auth = (_a = options.auth) != null ? _a : {};
+  const user = (_b = auth.user) != null ? _b : readEnv("WP_AUTH_USER");
+  const appPassword = (_c = auth.appPassword) != null ? _c : readEnv("WP_AUTH_APP_PASSWORD");
+  const token = (_d = auth.token) != null ? _d : readEnv("WP_AUTH_TOKEN");
+  const headers = (_e = auth.headers) != null ? _e : parseHeadersJson(readEnv("WP_AUTH_HEADERS_JSON"));
+  const resolved = {
+    type: auth.type,
+    user: user == null ? void 0 : user.trim(),
+    appPassword: appPassword == null ? void 0 : appPassword.trim(),
+    token: token == null ? void 0 : token.trim(),
+    headers
+  };
+  const type = resolveAuthType(resolved);
+  if (type === "none") {
+    return { type: "none" };
+  }
+  if (type === "basic") {
+    if (!resolved.user || !resolved.appPassword) {
+      throw new WpClientError(
+        "INVALID_CONFIG",
+        "Basic auth requires WP_AUTH_USER and WP_AUTH_APP_PASSWORD (or auth.user/auth.appPassword)."
+      );
+    }
+    return { type, user: resolved.user, appPassword: resolved.appPassword };
+  }
+  if (type === "bearer") {
+    if (!resolved.token) {
+      throw new WpClientError("INVALID_CONFIG", "Bearer auth requires WP_AUTH_TOKEN (or auth.token).");
+    }
+    return { type, token: resolved.token };
+  }
+  if (!resolved.headers || Object.keys(resolved.headers).length === 0) {
+    throw new WpClientError(
+      "INVALID_CONFIG",
+      "Headers auth requires WP_AUTH_HEADERS_JSON (or auth.headers) with at least one header."
+    );
+  }
+  return { type, headers: resolved.headers };
+}
+function resolveRewriteLinks(options) {
+  const rules = options.rewriteLinks;
+  if (!rules) {
+    return void 0;
+  }
+  if (!Array.isArray(rules)) {
+    throw new WpClientError("INVALID_CONFIG", "rewriteLinks must be an array.");
+  }
+  for (const [index, rule] of rules.entries()) {
+    if (!rule || typeof rule !== "object") {
+      throw new WpClientError("INVALID_CONFIG", `rewriteLinks[${index}] must be an object.`);
+    }
+    if (!rule.source || typeof rule.source !== "string") {
+      throw new WpClientError("INVALID_CONFIG", `rewriteLinks[${index}].source must be a non-empty string.`);
+    }
+    if (!rule.source.startsWith("/")) {
+      throw new WpClientError("INVALID_CONFIG", `rewriteLinks[${index}].source must start with '/'.`);
+    }
+    const hasDestination = typeof rule.destination === "string" && rule.destination.length > 0;
+    const isIgnore = rule.action === "ignore";
+    const hasTransform = typeof rule.transform === "function";
+    if (!hasDestination && !isIgnore && !hasTransform) {
+      throw new WpClientError(
+        "INVALID_CONFIG",
+        `rewriteLinks[${index}] must define destination, action: "ignore", or transform.`
+      );
+    }
+    if (hasDestination && !rule.destination.startsWith("/")) {
+      throw new WpClientError("INVALID_CONFIG", `rewriteLinks[${index}].destination must start with '/'.`);
+    }
+  }
+  return rules;
+}
+function resolveClassNameMap(options) {
+  const map = options.classNameMap;
+  if (!map) {
+    return void 0;
+  }
+  if (typeof map !== "object" || Array.isArray(map)) {
+    throw new WpClientError("INVALID_CONFIG", "classNameMap must be an object.");
+  }
+  for (const [key, value] of Object.entries(map)) {
+    if (!key.trim()) {
+      throw new WpClientError("INVALID_CONFIG", "classNameMap keys must be non-empty class names.");
+    }
+    if (typeof value === "string") {
+      continue;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new WpClientError("INVALID_CONFIG", `classNameMap[${key}] must be a string or object.`);
+    }
+    if (typeof value.className !== "string" || !value.className.trim()) {
+      throw new WpClientError("INVALID_CONFIG", `classNameMap[${key}].className must be a non-empty string.`);
+    }
+    if (value.mode !== void 0 && value.mode !== "append" && value.mode !== "replace" && value.mode !== "replace-all") {
+      throw new WpClientError(
+        "INVALID_CONFIG",
+        `classNameMap[${key}].mode must be "append", "replace", or "replace-all".`
+      );
+    }
+  }
+  return map;
+}
+function resolveClientOptions(options = {}) {
+  var _a, _b, _c, _d, _e;
+  const wpUrl = (_a = options.wpUrl) != null ? _a : readEnv("WP_URL");
+  if (!wpUrl) {
+    throw new WpClientError("INVALID_CONFIG", "Missing WordPress URL. Set WP_URL or pass wpUrl.");
+  }
+  const globalFetch = globalThis.fetch;
+  const fetchImpl = (_b = options.fetchImpl) != null ? _b : globalFetch;
+  if (!fetchImpl) {
+    throw new WpClientError("INVALID_CONFIG", "Global fetch is unavailable. Pass fetchImpl explicitly.");
+  }
+  const perPage = (_c = options.perPage) != null ? _c : DEFAULT_PER_PAGE;
+  const endpoint = normalizePathOrUrl(
+    (_e = (_d = options.endpoint) != null ? _d : readEnv("WP_ENDPOINT")) != null ? _e : DEFAULT_ENDPOINT,
+    "WP_ENDPOINT"
+  );
+  return {
+    wpUrl: normalizeWpUrl(wpUrl),
+    endpoint,
+    perPage,
+    auth: resolveAuth(options),
+    rewriteLinks: resolveRewriteLinks(options),
+    classNameMap: resolveClassNameMap(options),
+    fetchImpl,
+    requestInit: options.requestInit
+  };
+}
+
+// src/transport/graphql.ts
+function resolveUrl(baseUrl, pathOrUrl) {
+  if (/^https?:\/\//i.test(pathOrUrl)) {
+    return pathOrUrl;
+  }
+  return `${baseUrl}${pathOrUrl}`;
+}
+function buildRequestInit(options) {
+  var _a;
+  return __spreadValues({}, (_a = options.requestInit) != null ? _a : {});
+}
+function buildAuthHeaderValue(user, appPassword) {
+  const plain = `${user}:${appPassword}`;
+  if (typeof globalThis.btoa !== "function") {
+    throw new WpClientError("INVALID_CONFIG", "Global btoa is unavailable for auth header encoding.");
+  }
+  return `Basic ${globalThis.btoa(plain)}`;
+}
+function applyAuth(requestInit, options) {
+  var _a, _b;
+  const headers = new Headers((_a = requestInit.headers) != null ? _a : void 0);
+  if (options.auth.type === "basic") {
+    headers.set("Authorization", buildAuthHeaderValue(options.auth.user, options.auth.appPassword));
+  } else if (options.auth.type === "bearer") {
+    headers.set("Authorization", `Bearer ${options.auth.token}`);
+  } else if (options.auth.type === "headers") {
+    for (const [key, value] of Object.entries((_b = options.auth.headers) != null ? _b : {})) {
+      headers.set(key, value);
+    }
+  }
+  return __spreadProps(__spreadValues({}, requestInit), {
+    headers
+  });
+}
+function normalizeGraphqlErrors(payload) {
+  const errors = payload == null ? void 0 : payload.errors;
+  if (!Array.isArray(errors)) {
+    return void 0;
+  }
+  return errors.filter((error) => !!error && typeof error === "object");
+}
+async function queryGraphqlFromApi(options, params) {
+  var _a, _b, _c;
+  if (!((_a = params.query) == null ? void 0 : _a.trim())) {
+    throw new WpClientError("INVALID_INPUT", "queryGraphql requires query.");
+  }
+  const requestInit = applyAuth(buildRequestInit(options), options);
+  const headers = new Headers((_b = requestInit.headers) != null ? _b : void 0);
+  headers.set("Content-Type", "application/json");
+  let response;
+  try {
+    response = await options.fetchImpl(resolveUrl(options.wpUrl, options.endpoint), __spreadProps(__spreadValues({}, requestInit), {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        query: params.query,
+        variables: (_c = params.variables) != null ? _c : {}
+      })
+    }));
+  } catch (error) {
+    if (error instanceof WpClientError) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : "Unknown fetch error.";
+    throw new WpClientError("REQUEST_FAILED", `WordPress request failed: ${message}`);
+  }
+  if (!response.ok) {
+    let details = "";
+    try {
+      details = await response.text();
+    } catch (e) {
+      details = "";
+    }
+    const suffix = details ? `: ${details}` : ".";
+    throw new WpClientError("REQUEST_FAILED", `WordPress request failed with status ${response.status}${suffix}`, response.status);
+  }
+  let payload;
+  try {
+    payload = await response.json();
+  } catch (e) {
+    throw new WpClientError("INVALID_RESPONSE", "WordPress response was not valid JSON.");
+  }
+  if (!payload || typeof payload !== "object") {
+    throw new WpClientError("INVALID_RESPONSE", "WordPress GraphQL response must be an object.");
+  }
+  return {
+    data: payload.data,
+    errors: normalizeGraphqlErrors(payload)
+  };
+}
+
+// src/transport/rest.ts
+function parseHeaderInt(value, headerName) {
+  const parsed = Number.parseInt(value != null ? value : "", 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new WpClientError("INVALID_RESPONSE", `Missing or invalid ${headerName} response header.`);
+  }
+  return parsed;
+}
+function buildRequestInit2(options) {
+  var _a;
+  return __spreadValues({}, (_a = options.requestInit) != null ? _a : {});
+}
+function buildAuthHeaderValue2(user, appPassword) {
+  const plain = `${user}:${appPassword}`;
+  if (typeof globalThis.btoa !== "function") {
+    throw new WpClientError("INVALID_CONFIG", "Global btoa is unavailable for auth header encoding.");
+  }
+  return `Basic ${globalThis.btoa(plain)}`;
+}
+function applyAuth2(requestInit, options, authRequired) {
+  var _a, _b;
+  if (authRequired && options.auth.type === "none") {
+    throw new WpClientError(
+      "INVALID_CONFIG",
+      "Missing auth for non-public request. Configure WP_AUTH_TYPE and related credentials/headers."
+    );
+  }
+  const headers = new Headers((_a = requestInit.headers) != null ? _a : void 0);
+  if (options.auth.type === "basic") {
+    headers.set("Authorization", buildAuthHeaderValue2(options.auth.user, options.auth.appPassword));
+  } else if (options.auth.type === "bearer") {
+    headers.set("Authorization", `Bearer ${options.auth.token}`);
+  } else if (options.auth.type === "headers") {
+    for (const [key, value] of Object.entries((_b = options.auth.headers) != null ? _b : {})) {
+      headers.set(key, value);
+    }
+  }
+  return __spreadProps(__spreadValues({}, requestInit), {
+    headers
+  });
+}
+function resolveUrl2(baseUrl, pathOrUrl) {
+  if (/^https?:\/\//i.test(pathOrUrl)) {
+    return pathOrUrl;
+  }
+  return `${baseUrl}${pathOrUrl}`;
+}
+function appendRestQueryParams(pathOrUrl, params) {
+  if (!params) {
+    return pathOrUrl;
+  }
+  const [base, query = ""] = pathOrUrl.split("?");
+  const search = new URLSearchParams(query);
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    search.set(key, String(value));
+  }
+  const encoded = search.toString();
+  return encoded ? `${base}?${encoded}` : base;
+}
+async function throwRestRequestFailed(response) {
+  let wpCode;
+  let wpMessage;
+  let wpData;
+  try {
+    const payload = await response.json();
+    if (typeof payload.code === "string") {
+      wpCode = payload.code;
+    }
+    if (typeof payload.message === "string") {
+      wpMessage = payload.message;
+    }
+    wpData = payload.data;
+  } catch (e) {
+  }
+  const message = wpMessage ? `WordPress request failed with status ${response.status}: ${wpMessage}` : `WordPress request failed with status ${response.status}.`;
+  throw new WpClientError("REQUEST_FAILED", message, response.status, {
+    wpCode,
+    wpMessage,
+    wpData
+  });
+}
+function toBlogTerm(term) {
+  var _a, _b;
+  return {
+    id: term.id,
+    slug: (_a = term.slug) != null ? _a : "",
+    name: (_b = term.name) != null ? _b : "",
+    count: Number.isFinite(term.count) ? Number(term.count) : 0
+  };
+}
+function resolveRestOrder(order) {
+  switch (order) {
+    case "alphabetical":
+      return { orderby: "name", order: "asc" };
+    case "count":
+      return { orderby: "count", order: "desc" };
+    default:
+      return {};
+  }
+}
+async function fetchPostsFromRest(options, input) {
+  const params = new URLSearchParams({
+    page: String(input.page),
+    per_page: String(input.perPage),
+    _embed: "author,wp:featuredmedia,wp:term"
+  });
+  async function resolveTermIdBySlug(taxonomyPath, slug) {
+    const requestInit2 = applyAuth2(buildRequestInit2(options), options, input.authRequired);
+    const url2 = `${resolveUrl2(
+      options.wpUrl,
+      `/wp-json/wp/v2/${taxonomyPath}`
+    )}?slug=${encodeURIComponent(slug)}&per_page=1`;
+    let response2;
+    try {
+      response2 = await options.fetchImpl(url2, requestInit2);
+    } catch (error) {
+      if (error instanceof WpClientError) {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : "Unknown fetch error.";
+      throw new WpClientError("REQUEST_FAILED", `WordPress request failed: ${message}`);
+    }
+    if (!response2.ok) {
+      await throwRestRequestFailed(response2);
+    }
+    let payload2;
+    try {
+      payload2 = await response2.json();
+    } catch (e) {
+      throw new WpClientError("INVALID_RESPONSE", "WordPress response was not valid JSON.");
+    }
+    if (!Array.isArray(payload2)) {
+      throw new WpClientError("INVALID_RESPONSE", "WordPress terms response must be an array.");
+    }
+    const first = payload2[0];
+    if (!(first == null ? void 0 : first.id) || !Number.isInteger(first.id) || first.id <= 0) {
+      return null;
+    }
+    return first.id;
+  }
+  if (input.slug) {
+    params.set("slug", input.slug);
+  }
+  if (input.id !== void 0) {
+    params.set("include", String(input.id));
+  }
+  if (input.search) {
+    params.set("search", input.search);
+  }
+  if (input.status) {
+    params.set("status", input.status);
+  }
+  if (input.categorySlug) {
+    const categoryId = await resolveTermIdBySlug("categories", input.categorySlug);
+    if (!categoryId) {
+      return { posts: [], totalItems: 0, totalPages: 0 };
+    }
+    params.set("categories", String(categoryId));
+  }
+  if (input.tagSlug) {
+    const tagId = await resolveTermIdBySlug("tags", input.tagSlug);
+    if (!tagId) {
+      return { posts: [], totalItems: 0, totalPages: 0 };
+    }
+    params.set("tags", String(tagId));
+  }
+  if (input.context) {
+    params.set("context", input.context);
+  }
+  const url = `${resolveUrl2(options.wpUrl, options.endpoint)}?${params.toString()}`;
+  const requestInit = applyAuth2(buildRequestInit2(options), options, input.authRequired);
+  let response;
+  try {
+    response = await options.fetchImpl(url, requestInit);
+  } catch (error) {
+    if (error instanceof WpClientError) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : "Unknown fetch error.";
+    throw new WpClientError("REQUEST_FAILED", `WordPress request failed: ${message}`);
+  }
+  if (!response.ok) {
+    await throwRestRequestFailed(response);
+  }
+  let payload;
+  try {
+    payload = await response.json();
+  } catch (e) {
+    throw new WpClientError("INVALID_RESPONSE", "WordPress response was not valid JSON.");
+  }
+  if (!Array.isArray(payload)) {
+    throw new WpClientError("INVALID_RESPONSE", "WordPress posts response must be an array.");
+  }
+  return {
+    posts: payload,
+    totalItems: parseHeaderInt(response.headers.get("X-WP-Total"), "X-WP-Total"),
+    totalPages: parseHeaderInt(response.headers.get("X-WP-TotalPages"), "X-WP-TotalPages")
+  };
+}
+async function fetchPostsFromApi(options, input) {
+  return fetchPostsFromRest(options, input);
+}
+async function fetchTermsFromRest(options, input) {
+  const requestInit = applyAuth2(buildRequestInit2(options), options, false);
+  const basePath = input.taxonomy === "categories" ? "/wp-json/wp/v2/categories" : "/wp-json/wp/v2/tags";
+  const { orderby, order } = resolveRestOrder(input.order);
+  const url = appendRestQueryParams(basePath, {
+    per_page: 100,
+    hide_empty: true,
+    orderby,
+    order
+  });
+  let response;
+  try {
+    response = await options.fetchImpl(resolveUrl2(options.wpUrl, url), requestInit);
+  } catch (error) {
+    if (error instanceof WpClientError) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : "Unknown fetch error.";
+    throw new WpClientError("REQUEST_FAILED", `WordPress request failed: ${message}`);
+  }
+  if (!response.ok) {
+    await throwRestRequestFailed(response);
+  }
+  let payload;
+  try {
+    payload = await response.json();
+  } catch (e) {
+    throw new WpClientError("INVALID_RESPONSE", "WordPress response was not valid JSON.");
+  }
+  if (!Array.isArray(payload)) {
+    throw new WpClientError("INVALID_RESPONSE", "WordPress terms response must be an array.");
+  }
+  return payload.map((term) => {
+    var _a, _b, _c;
+    const t = term;
+    if (!t.id || !Number.isInteger(t.id) || t.id <= 0) {
+      return null;
+    }
+    return toBlogTerm({
+      id: t.id,
+      slug: (_a = t.slug) != null ? _a : "",
+      name: (_b = t.name) != null ? _b : "",
+      count: (_c = t.count) != null ? _c : 0
+    });
+  }).filter((term) => term !== null);
+}
+async function fetchTermsFromApi(options, input) {
+  return fetchTermsFromRest(options, input);
+}
+function toBlogAuthor(author) {
+  if (!(author == null ? void 0 : author.id) || !Number.isInteger(author.id) || author.id <= 0) {
+    return null;
+  }
+  return __spreadValues({}, author);
+}
+async function fetchAuthorsFromRest(options, input) {
+  const requestInit = applyAuth2(buildRequestInit2(options), options, false);
+  const url = appendRestQueryParams("/wp-json/wp/v2/users", {
+    page: input.page,
+    per_page: input.perPage
+  });
+  let response;
+  try {
+    response = await options.fetchImpl(resolveUrl2(options.wpUrl, url), requestInit);
+  } catch (error) {
+    if (error instanceof WpClientError) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : "Unknown fetch error.";
+    throw new WpClientError("REQUEST_FAILED", `WordPress request failed: ${message}`);
+  }
+  if (!response.ok) {
+    await throwRestRequestFailed(response);
+  }
+  let payload;
+  try {
+    payload = await response.json();
+  } catch (e) {
+    throw new WpClientError("INVALID_RESPONSE", "WordPress response was not valid JSON.");
+  }
+  if (!Array.isArray(payload)) {
+    throw new WpClientError("INVALID_RESPONSE", "WordPress authors response must be an array.");
+  }
+  return payload.map((author) => toBlogAuthor(author)).filter((author) => author !== null);
+}
+async function fetchAuthorByIdFromRest(options, id) {
+  const requestInit = applyAuth2(buildRequestInit2(options), options, false);
+  const url = `/wp-json/wp/v2/users/${id}`;
+  let response;
+  try {
+    response = await options.fetchImpl(resolveUrl2(options.wpUrl, url), requestInit);
+  } catch (error) {
+    if (error instanceof WpClientError) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : "Unknown fetch error.";
+    throw new WpClientError("REQUEST_FAILED", `WordPress request failed: ${message}`);
+  }
+  if (response.status === 404) {
+    return null;
+  }
+  if (!response.ok) {
+    await throwRestRequestFailed(response);
+  }
+  let payload;
+  try {
+    payload = await response.json();
+  } catch (e) {
+    throw new WpClientError("INVALID_RESPONSE", "WordPress response was not valid JSON.");
+  }
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new WpClientError("INVALID_RESPONSE", "WordPress author response must be an object.");
+  }
+  return toBlogAuthor(payload);
+}
+async function fetchAuthorsFromApi(options, input) {
+  return fetchAuthorsFromRest(options, input);
+}
+async function fetchAuthorByIdFromApi(options, id) {
+  return fetchAuthorByIdFromRest(options, id);
+}
+async function queryRawFromApi(options, params) {
+  var _a, _b, _c, _d;
+  if (!((_b = (_a = params.rest) == null ? void 0 : _a.path) == null ? void 0 : _b.trim())) {
+    throw new WpClientError("INVALID_INPUT", "queryRaw requires rest.path.");
+  }
+  const method = ((_c = params.rest.method) != null ? _c : "GET").toUpperCase();
+  const withParams = appendRestQueryParams(params.rest.path, params.rest.params);
+  const requestInit = applyAuth2(buildRequestInit2(options), options, params.authRequired);
+  const headers = new Headers((_d = requestInit.headers) != null ? _d : void 0);
+  if (params.rest.headers) {
+    for (const [key, value] of Object.entries(params.rest.headers)) {
+      headers.set(key, value);
+    }
+  }
+  let body;
+  if (params.rest.body !== void 0) {
+    if (typeof params.rest.body === "string") {
+      body = params.rest.body;
+    } else {
+      headers.set("Content-Type", "application/json");
+      body = JSON.stringify(params.rest.body);
+    }
+  }
+  let response;
+  try {
+    response = await options.fetchImpl(resolveUrl2(options.wpUrl, withParams), __spreadProps(__spreadValues({}, requestInit), {
+      method,
+      headers,
+      body
+    }));
+  } catch (error) {
+    if (error instanceof WpClientError) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : "Unknown fetch error.";
+    throw new WpClientError("REQUEST_FAILED", `WordPress request failed: ${message}`);
+  }
+  if (!response.ok) {
+    await throwRestRequestFailed(response);
+  }
+  try {
+    return await response.json();
+  } catch (e) {
+    throw new WpClientError("INVALID_RESPONSE", "WordPress response was not valid JSON.");
+  }
+}
+
+// src/domain/normalize.ts
+function htmlToPlainText(value) {
+  if (!value) {
+    return "";
+  }
+  return value.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+}
+function getFeaturedImageUrl(post) {
+  var _a, _b, _c;
+  const media = (_a = post._embedded) == null ? void 0 : _a["wp:featuredmedia"];
+  if (!Array.isArray(media) || media.length === 0) {
+    return null;
+  }
+  return (_c = (_b = media[0]) == null ? void 0 : _b.source_url) != null ? _c : null;
+}
+function normalizeTerm(term) {
+  var _a, _b;
+  if (!Number.isInteger(term.id) || term.id <= 0) {
+    return null;
+  }
+  return {
+    id: term.id,
+    slug: (_a = term.slug) != null ? _a : "",
+    name: (_b = term.name) != null ? _b : "",
+    count: typeof term.count === "number" ? term.count : 0
+  };
+}
+function getTermsByTaxonomy(post, taxonomy) {
+  var _a;
+  const groups = (_a = post._embedded) == null ? void 0 : _a["wp:term"];
+  if (!Array.isArray(groups)) {
+    return [];
+  }
+  const terms = [];
+  for (const group of groups) {
+    if (!Array.isArray(group)) {
+      continue;
+    }
+    for (const rawTerm of group) {
+      if (!rawTerm || rawTerm.taxonomy !== taxonomy) {
+        continue;
+      }
+      const term = normalizeTerm(rawTerm);
+      if (term) {
+        terms.push(term);
+      }
+    }
+  }
+  return terms;
+}
+function normalizeText(value, textMode) {
+  if (textMode === "html") {
+    return value != null ? value : "";
+  }
+  return htmlToPlainText(value);
+}
+function getEmbeddedAuthor(post) {
+  var _a;
+  const authors = (_a = post._embedded) == null ? void 0 : _a.author;
+  if (!Array.isArray(authors) || authors.length === 0) {
+    return null;
+  }
+  const author = authors[0];
+  if (!author || !Number.isInteger(author.id) || author.id <= 0) {
+    return null;
+  }
+  return author;
+}
+function isSkippableProtocol(rawHref) {
+  const normalized = rawHref.trim().toLowerCase();
+  return normalized.startsWith("mailto:") || normalized.startsWith("tel:") || normalized.startsWith("javascript:");
+}
+function normalizePathForMatch(pathname) {
+  const collapsed = pathname.replace(/\/{2,}/g, "/");
+  const trimmed = collapsed.replace(/\/+$/g, "");
+  return trimmed || "/";
+}
+function toUrl(href, wpUrl) {
+  try {
+    if (/^\/\//.test(href)) {
+      const wpProtocol = new URL(wpUrl).protocol;
+      return new URL(`${wpProtocol}${href}`);
+    }
+    return new URL(href, wpUrl);
+  } catch (e) {
+    return null;
+  }
+}
+function isInternalWpUrl(url, wpUrl) {
+  try {
+    const wpHost = new URL(wpUrl).host.toLowerCase();
+    return url.host.toLowerCase() === wpHost;
+  } catch (e) {
+    return false;
+  }
+}
+function parsePattern(pattern) {
+  return normalizePathForMatch(pattern).split("/").filter(Boolean);
+}
+function matchPathPattern(pathname, sourcePattern) {
+  const pathParts = normalizePathForMatch(pathname).split("/").filter(Boolean);
+  const patternParts = parsePattern(sourcePattern);
+  if (pathParts.length !== patternParts.length) {
+    return null;
+  }
+  const params = {};
+  for (let i = 0; i < patternParts.length; i += 1) {
+    const patternPart = patternParts[i];
+    const pathPart = pathParts[i];
+    if (patternPart.startsWith(":")) {
+      const key = patternPart.slice(1);
+      if (!key) {
+        return null;
+      }
+      params[key] = pathPart;
+      continue;
+    }
+    if (patternPart !== pathPart) {
+      return null;
+    }
+  }
+  return params;
+}
+function applyDestinationPattern(destination, params) {
+  const output = normalizePathForMatch(destination);
+  return output.replace(/:([A-Za-z0-9_]+)/g, (_match, key) => {
+    var _a;
+    return (_a = params[key]) != null ? _a : "";
+  });
+}
+function applyRewriteRule(href, wpUrl, rules) {
+  if (isSkippableProtocol(href)) {
+    return href;
+  }
+  const url = toUrl(href, wpUrl);
+  if (!url || !isInternalWpUrl(url, wpUrl)) {
+    return href;
+  }
+  const originalPathname = normalizePathForMatch(url.pathname);
+  const context = {
+    href: url.toString(),
+    pathname: originalPathname,
+    search: url.search,
+    hash: url.hash
+  };
+  for (const rule of rules) {
+    const source = rule.source.trim();
+    if (!source) {
+      continue;
+    }
+    if (rule.action === "ignore") {
+      if (context.href.includes(source) || context.pathname.includes(normalizePathForMatch(source))) {
+        return href;
+      }
+      continue;
+    }
+    const params = matchPathPattern(context.pathname, source);
+    if (!params) {
+      continue;
+    }
+    if (typeof rule.transform === "function") {
+      const transformed = rule.transform(context);
+      return typeof transformed === "string" && transformed ? transformed : href;
+    }
+    if (rule.destination) {
+      const rewrittenPath = applyDestinationPattern(rule.destination, params);
+      const finalPath = rewrittenPath.startsWith("/") ? rewrittenPath : `/${rewrittenPath}`;
+      return `${finalPath}${context.search}${context.hash}`;
+    }
+  }
+  return href;
+}
+function rewriteContentLinks(contentHtml, options) {
+  const rules = options.rewriteLinks;
+  if (!rules || rules.length === 0 || !contentHtml.includes("<a ")) {
+    return contentHtml;
+  }
+  return contentHtml.replace(/(<a\b[^>]*\bhref\s*=\s*)(["'])([^"']+)(\2)/gi, (_match, prefix, quote, href, suffix) => {
+    const nextHref = applyRewriteRule(href, options.wpUrl, rules);
+    return `${prefix}${quote}${nextHref}${suffix}`;
+  });
+}
+function splitClassNames(value) {
+  return value.split(/\s+/).map((token) => token.trim()).filter(Boolean);
+}
+function resolveClassMapValue(value) {
+  var _a;
+  if (typeof value === "string") {
+    return { className: value, mode: "append" };
+  }
+  return {
+    className: value.className,
+    mode: (_a = value.mode) != null ? _a : "append"
+  };
+}
+function transformContentClasses(contentHtml, classNameMap) {
+  if (!contentHtml || !contentHtml.includes("class=")) {
+    return contentHtml;
+  }
+  return contentHtml.replace(
+    /(<[a-zA-Z][^>]*\bclass\s*=\s*)(["'])([^"']*)(\2)/g,
+    (_match, prefix, quote, classValue, suffix) => {
+      const tokens = splitClassNames(classValue);
+      if (tokens.length === 0) {
+        return `${prefix}${quote}${classValue}${suffix}`;
+      }
+      let replaceAllTokens = null;
+      for (const token of tokens) {
+        const mapped = classNameMap[token];
+        if (!mapped) {
+          continue;
+        }
+        const { className, mode } = resolveClassMapValue(mapped);
+        if (mode === "replace-all") {
+          replaceAllTokens = splitClassNames(className);
+          break;
+        }
+      }
+      if (replaceAllTokens) {
+        const deduped2 = Array.from(new Set(replaceAllTokens));
+        return `${prefix}${quote}${deduped2.join(" ")}${suffix}`;
+      }
+      const nextClasses = [];
+      for (const token of tokens) {
+        const mapped = classNameMap[token];
+        if (!mapped) {
+          nextClasses.push(token);
+          continue;
+        }
+        const { className, mode } = resolveClassMapValue(mapped);
+        const mappedTokens = splitClassNames(className);
+        if (mode === "append") {
+          nextClasses.push(token, ...mappedTokens);
+        } else {
+          nextClasses.push(...mappedTokens);
+        }
+      }
+      const deduped = Array.from(new Set(nextClasses));
+      return `${prefix}${quote}${deduped.join(" ")}${suffix}`;
+    }
+  );
+}
+function normalizePost(post, textMode = "plain", options) {
+  var _a, _b;
+  const summary = normalizePostSummary(post, textMode);
+  const rawContentHtml = (_b = (_a = post.content) == null ? void 0 : _a.rendered) != null ? _b : "";
+  const rewrittenHtml = options ? rewriteContentLinks(rawContentHtml, options) : rawContentHtml;
+  const contentHtml = (options == null ? void 0 : options.classNameMap) && Object.keys(options.classNameMap).length > 0 ? transformContentClasses(rewrittenHtml, options.classNameMap) : rewrittenHtml;
+  return __spreadProps(__spreadValues({}, summary), {
+    contentHtml
+  });
+}
+function normalizePostSummary(post, textMode = "plain") {
+  var _a, _b;
+  return {
+    id: post.id,
+    slug: post.slug,
+    url: post.link,
+    date: post.date,
+    modified: post.modified,
+    publishedDate: post.date,
+    updatedDate: post.modified,
+    title: normalizeText((_a = post.title) == null ? void 0 : _a.rendered, textMode),
+    excerpt: normalizeText((_b = post.excerpt) == null ? void 0 : _b.rendered, textMode),
+    featuredImageUrl: getFeaturedImageUrl(post),
+    author: getEmbeddedAuthor(post),
+    categories: getTermsByTaxonomy(post, "category"),
+    tags: getTermsByTaxonomy(post, "post_tag")
+  };
+}
+
+// src/domain/posts.ts
+function ensurePositiveInt(value, label) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new WpClientError("INVALID_INPUT", `${label} must be a positive integer.`);
+  }
+  return value;
+}
+function resolvePage(page) {
+  return ensurePositiveInt(page != null ? page : 1, "page");
+}
+function resolvePerPage(perPage, fallback) {
+  return ensurePositiveInt(perPage != null ? perPage : fallback, "perPage");
+}
+function resolveOptionalSlug(value, label) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new WpClientError("INVALID_INPUT", `${label} must be a non-empty string.`);
+  }
+  return trimmed;
+}
+function resolveRequiredQuery(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new WpClientError("INVALID_INPUT", "query must be a non-empty string.");
+  }
+  return trimmed;
+}
+function resolveStatus(status) {
+  return status != null ? status : "publish";
+}
+function isNonPublicStatus(status) {
+  return status !== "publish";
+}
+function resolvePostId(id) {
+  return ensurePositiveInt(id, "id");
+}
+function resolveTermOrder(order) {
+  return order != null ? order : "default";
+}
+function resolveTextMode(textMode) {
+  return textMode != null ? textMode : "plain";
+}
+function resolveAuthorsPage(page) {
+  return ensurePositiveInt(page != null ? page : 1, "page");
+}
+function applySelect(value, select) {
+  if (!select || select.length === 0) {
+    return value;
+  }
+  const output = {};
+  for (const key of select) {
+    if (key in value) {
+      output[key] = value[key];
+    }
+  }
+  return output;
+}
+function createPostsApi(options) {
+  return {
+    async getPosts(params = {}) {
+      const page = resolvePage(params.page);
+      const perPage = resolvePerPage(params.perPage, options.perPage);
+      const status = resolveStatus(params.status);
+      const categorySlug = resolveOptionalSlug(params.categorySlug, "categorySlug");
+      const tagSlug = resolveOptionalSlug(params.tagSlug, "tagSlug");
+      const textMode = resolveTextMode(params.textMode);
+      const select = params.select;
+      const result = await fetchPostsFromApi(options, {
+        page,
+        perPage,
+        status,
+        categorySlug,
+        tagSlug,
+        context: isNonPublicStatus(status) ? "edit" : void 0,
+        authRequired: isNonPublicStatus(status)
+      });
+      const items = result.posts.map(
+        (post) => applySelect(normalizePostSummary(post, textMode), select)
+      );
+      return {
+        items,
+        pagination: {
+          page,
+          perPage,
+          totalItems: result.totalItems,
+          totalPages: result.totalPages
+        }
+      };
+    },
+    async searchPosts(params) {
+      const query = resolveRequiredQuery(params.query);
+      const page = resolvePage(params.page);
+      const perPage = resolvePerPage(params.perPage, options.perPage);
+      const status = resolveStatus(params.status);
+      const categorySlug = resolveOptionalSlug(params.categorySlug, "categorySlug");
+      const tagSlug = resolveOptionalSlug(params.tagSlug, "tagSlug");
+      const textMode = resolveTextMode(params.textMode);
+      const select = params.select;
+      const result = await fetchPostsFromApi(options, {
+        page,
+        perPage,
+        search: query,
+        status,
+        categorySlug,
+        tagSlug,
+        context: isNonPublicStatus(status) ? "edit" : void 0,
+        authRequired: isNonPublicStatus(status)
+      });
+      const items = result.posts.map(
+        (post) => applySelect(normalizePostSummary(post, textMode), select)
+      );
+      return {
+        items,
+        pagination: {
+          page,
+          perPage,
+          totalItems: result.totalItems,
+          totalPages: result.totalPages
+        }
+      };
+    },
+    async getPostBySlug(slug, params = {}) {
+      const trimmedSlug = slug.trim();
+      if (!trimmedSlug) {
+        throw new WpClientError("INVALID_INPUT", "slug must be a non-empty string.");
+      }
+      const status = resolveStatus(params.status);
+      const textMode = resolveTextMode(params.textMode);
+      const select = params.select;
+      const result = await fetchPostsFromApi(options, {
+        page: 1,
+        perPage: 1,
+        slug: trimmedSlug,
+        status,
+        context: isNonPublicStatus(status) ? "edit" : void 0,
+        authRequired: isNonPublicStatus(status)
+      });
+      const post = result.posts[0];
+      return post ? applySelect(normalizePost(post, textMode, options), select) : null;
+    },
+    async getPostById(id, params = {}) {
+      const postId = resolvePostId(id);
+      const status = resolveStatus(params.status);
+      const textMode = resolveTextMode(params.textMode);
+      const select = params.select;
+      const result = await fetchPostsFromApi(options, {
+        page: 1,
+        perPage: 1,
+        id: postId,
+        status,
+        context: isNonPublicStatus(status) ? "edit" : void 0,
+        authRequired: isNonPublicStatus(status)
+      });
+      const post = result.posts[0];
+      return post ? applySelect(normalizePost(post, textMode, options), select) : null;
+    },
+    async queryRaw(params) {
+      return queryRawFromApi(options, params);
+    },
+    async queryGraphql(params) {
+      return queryGraphqlFromApi(options, params);
+    },
+    async getCategories(params = {}) {
+      return fetchTermsFromApi(options, { taxonomy: "categories", order: resolveTermOrder(params.order) });
+    },
+    async getTags(params = {}) {
+      return fetchTermsFromApi(options, { taxonomy: "tags", order: resolveTermOrder(params.order) });
+    },
+    async getAuthors(params = {}) {
+      const page = resolveAuthorsPage(params.page);
+      const perPage = resolvePerPage(params.perPage, options.perPage);
+      return fetchAuthorsFromApi(options, { page, perPage });
+    },
+    async getAuthorById(id) {
+      const authorId = ensurePositiveInt(id, "id");
+      return fetchAuthorByIdFromApi(options, authorId);
+    }
+  };
+}
+var defaultClient;
+function createWpBlogClient(clientOptions = {}) {
+  return createPostsApi(resolveClientOptions(clientOptions));
+}
+function getDefaultClient() {
+  if (!defaultClient) {
+    defaultClient = createWpBlogClient();
+  }
+  return defaultClient;
+}
+async function getPosts(params = {}) {
+  return getDefaultClient().getPosts(params);
+}
+async function searchPosts(params) {
+  return getDefaultClient().searchPosts(params);
+}
+async function getPostBySlug(slug, params = {}) {
+  return getDefaultClient().getPostBySlug(slug, params);
+}
+async function getPostById(id, params = {}) {
+  return getDefaultClient().getPostById(id, params);
+}
+async function queryRaw(params) {
+  return getDefaultClient().queryRaw(params);
+}
+async function queryGraphql(params) {
+  return getDefaultClient().queryGraphql(params);
+}
+async function getCategories(params = {}) {
+  return getDefaultClient().getCategories(params);
+}
+async function getTags(params = {}) {
+  return getDefaultClient().getTags(params);
+}
+async function getAuthors(params = {}) {
+  return getDefaultClient().getAuthors(params);
+}
+async function getAuthorById(id) {
+  return getDefaultClient().getAuthorById(id);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WpClientError,
+  createWpBlogClient,
+  getAuthorById,
+  getAuthors,
+  getCategories,
+  getPostById,
+  getPostBySlug,
+  getPosts,
+  getTags,
+  parseContentPlaceholders,
+  queryGraphql,
+  queryRaw,
+  searchPosts
+});