create-nextblock 0.15.10 → 0.16.2

package/templates/nextblock-template/lib/seo/fix-prompts.test.ts

@@ -0,0 +1,242 @@
+import { describe, expect, it } from 'vitest';
+
+import { auditSeo, buildSeoDocument, type SeoIssue } from '@nextblock-cms/utils/seo';
+
+import {
+  buildSeoFixContext,
+  buildSeoFixPrompt,
+  canFixIssueWithCortexAi,
+  SEO_FIX_CONTEXT_MAX_LENGTH,
+  SEO_FIX_PROMPT_MAX_LENGTH,
+  SEO_FIX_PROMPT_MIN_LENGTH,
+} from './fix-prompts';
+
+/**
+ * The audit panel cannot be rendered in a test — there is no DOM environment in
+ * this workspace and no React testing library — so these two builders are the
+ * only part of the "Fix with Cortex AI" path that can be pinned down. They are
+ * also the part where a mistake is invisible: an over-long prompt comes back as
+ * a bare 400 from a `z.strictObject` route, and a prompt missing its numbers
+ * produces a plausible-looking rewrite that does not actually fix anything.
+ */
+
+function issue(overrides: Partial<SeoIssue> = {}): SeoIssue {
+  return {
+    category: 'readability',
+    detail: 'Sentences average 34 words; 25 or fewer is easier to follow.',
+    fixable: true,
+    fixPrompt: 'Break the longest sentences into shorter ones.',
+    id: 'readability-long-sentences',
+    message: 'The sentences are long.',
+    severity: 'warning',
+    ...overrides,
+  };
+}
+
+describe('canFixIssueWithCortexAi', () => {
+  it('offers a fix when the audit marked the issue fixable and supplied an instruction', () => {
+    expect(canFixIssueWithCortexAi(issue())).toBe(true);
+  });
+
+  it('refuses an issue the audit marked unfixable', () => {
+    // A missing H1 is the real case: the audit deliberately declines to invent
+    // a page title, because that is an editorial decision rather than a rewrite.
+    expect(
+      canFixIssueWithCortexAi(
+        issue({
+          category: 'headings',
+          fixable: false,
+          fixPrompt: undefined,
+          id: 'headings-missing-h1',
+        })
+      )
+    ).toBe(false);
+  });
+
+  it('refuses a fixable issue that carries no instruction', () => {
+    // Without `fixPrompt` the request would be assembled entirely from the
+    // problem statement, and the model would answer by describing the problem.
+    expect(canFixIssueWithCortexAi(issue({ fixPrompt: undefined }))).toBe(false);
+    expect(canFixIssueWithCortexAi(issue({ fixPrompt: '   ' }))).toBe(false);
+  });
+
+  it('agrees with the audit engine on a real document', () => {
+    // Guards against the predicate drifting away from the engine's own verdicts:
+    // every issue this panel would offer to fix must actually carry the
+    // instruction the request is built from.
+    const document = buildSeoDocument(
+      '<h1>Tea</h1><h1>More tea</h1><p>Short page about tea leaves and water.</p>'
+    );
+    const result = auditSeo({ document, keyword: 'tea' });
+    const fixable = result.issues.filter(canFixIssueWithCortexAi);
+
+    expect(fixable.length).toBeGreaterThan(0);
+    for (const finding of fixable) {
+      expect(finding.fixPrompt?.trim()).toBeTruthy();
+    }
+    expect(result.issues.some((finding) => finding.id === 'headings-missing-h1')).toBe(false);
+  });
+
+  it('never offers to fix missing alt text, which needs the vision generator instead', () => {
+    const document = buildSeoDocument(
+      `<h1>Gallery</h1><p>${'photo '.repeat(40)}</p><img src="/a.png" alt="">`
+    );
+    const missingAlt = auditSeo({ document }).issues.find(
+      (finding) => finding.id === 'images-missing-alt'
+    );
+
+    expect(missingAlt).toBeDefined();
+    expect(canFixIssueWithCortexAi(missingAlt as SeoIssue)).toBe(false);
+  });
+});
+
+describe('buildSeoFixPrompt', () => {
+  it('leads with the audit instruction and repeats the concrete numbers', () => {
+    const prompt = buildSeoFixPrompt({ issue: issue(), wordCount: 118 });
+
+    expect(prompt.startsWith('Break the longest sentences into shorter ones.')).toBe(true);
+    expect(prompt).toContain('The sentences are long.');
+    expect(prompt).toContain('Sentences average 34 words');
+    expect(prompt).toContain('118 words');
+  });
+
+  it('names the focus keyphrase only when one is set', () => {
+    expect(buildSeoFixPrompt({ issue: issue(), keyword: 'green tea' })).toContain(
+      'focus keyphrase for this page is "green tea"'
+    );
+    expect(buildSeoFixPrompt({ issue: issue(), keyword: '   ' })).not.toContain('focus keyphrase');
+    expect(buildSeoFixPrompt({ issue: issue(), keyword: null })).not.toContain('focus keyphrase');
+  });
+
+  it('omits the word count when the caller has none', () => {
+    const prompt = buildSeoFixPrompt({ issue: issue() });
+
+    expect(prompt).not.toContain('currently runs to');
+    expect(prompt).not.toContain('NaN');
+  });
+
+  it('states the output contract so the fragment can be inserted verbatim', () => {
+    const prompt = buildSeoFixPrompt({ issue: issue() });
+
+    expect(prompt).toContain('HTML fragment');
+    expect(prompt).toContain('code fence');
+  });
+
+  it('survives an issue with no detail sentence', () => {
+    const prompt = buildSeoFixPrompt({ issue: issue({ detail: undefined }) });
+
+    expect(prompt).toContain('The SEO audit reported: The sentences are long.');
+    expect(prompt).not.toContain('undefined');
+  });
+
+  it('stays inside the schema length bounds even with an absurd instruction', () => {
+    const prompt = buildSeoFixPrompt({
+      issue: issue({ detail: 'x'.repeat(9000), fixPrompt: 'y'.repeat(9000) }),
+      keyword: 'z'.repeat(500),
+      wordCount: 4321,
+    });
+
+    expect(prompt.length).toBeLessThanOrEqual(SEO_FIX_PROMPT_MAX_LENGTH);
+    expect(prompt.length).toBeGreaterThanOrEqual(SEO_FIX_PROMPT_MIN_LENGTH);
+  });
+
+  it('produces a prompt long enough to pass the minimum for every real fixable issue', () => {
+    const document = buildSeoDocument(
+      '<h1>Tea</h1><h1>Tea again</h1><h4>Deep</h4><h2></h2><p>A very short page.</p>'
+    );
+    const result = auditSeo({
+      document,
+      keyword: 'coffee',
+      metaDescription: '',
+      metaTitle: '',
+    });
+    const fixable = result.issues.filter(canFixIssueWithCortexAi);
+
+    expect(fixable.length).toBeGreaterThan(3);
+    for (const finding of fixable) {
+      const prompt = buildSeoFixPrompt({
+        issue: finding,
+        keyword: 'coffee',
+        wordCount: result.readability.wordCount,
+      });
+      expect(prompt.length).toBeGreaterThanOrEqual(SEO_FIX_PROMPT_MIN_LENGTH);
+      expect(prompt.length).toBeLessThanOrEqual(SEO_FIX_PROMPT_MAX_LENGTH);
+    }
+  });
+});
+
+describe('buildSeoFixContext', () => {
+  it('short-circuits an empty document rather than describing nothing', () => {
+    const context = buildSeoFixContext({
+      documentText: '',
+      insertionMode: 'replace-empty-document',
+      wordCount: 0,
+    });
+
+    expect(context).toBe(
+      'Insertion target: empty editor. Create the initial content for this document.'
+    );
+  });
+
+  it('quotes the tail of the document when appending', () => {
+    const context = buildSeoFixContext({
+      documentText: `START ${'middle '.repeat(400)}END`,
+      insertionMode: 'append-to-end',
+    });
+
+    expect(context).toContain('END');
+    expect(context).not.toContain('START');
+    expect(context).toContain('Continue after the existing content');
+  });
+
+  it('quotes the head of the document when replacing a selection', () => {
+    const context = buildSeoFixContext({
+      documentText: `START ${'middle '.repeat(400)}END`,
+      insertionMode: 'replace-selection',
+      selectedText: 'the highlighted sentence',
+    });
+
+    expect(context).toContain('START');
+    expect(context).not.toContain('END');
+    expect(context).toContain('Selected text:\nthe highlighted sentence');
+    expect(context).toContain('Replace only the selected content');
+  });
+
+  it('includes the heading outline when one is supplied', () => {
+    const context = buildSeoFixContext({
+      documentText: 'Body copy.',
+      headingOutline: ['H1 Tea', 'H3 Water temperature'],
+      insertionMode: 'append-to-end',
+    });
+
+    expect(context).toContain('Heading outline:\nH1 Tea\nH3 Water temperature');
+  });
+
+  it('drops the optional sections instead of emitting empty labels', () => {
+    const context = buildSeoFixContext({
+      documentText: '   ',
+      headingOutline: [],
+      insertionMode: 'append-to-end',
+      selectedText: '   ',
+      wordCount: null,
+    });
+
+    expect(context).not.toContain('Heading outline');
+    expect(context).not.toContain('Selected text');
+    expect(context).not.toContain('Existing editor text');
+    expect(context).not.toContain('words.');
+    expect(context.startsWith('Insertion target: append-to-end.')).toBe(true);
+  });
+
+  it('never exceeds the 2000 character cap the route enforces', () => {
+    const context = buildSeoFixContext({
+      documentText: 'word '.repeat(50_000),
+      headingOutline: Array.from({ length: 200 }, (_, index) => `H2 Section ${index}`),
+      insertionMode: 'replace-selection',
+      selectedText: 'selected '.repeat(5_000),
+      wordCount: 50_000,
+    });
+
+    expect(context.length).toBeLessThanOrEqual(SEO_FIX_CONTEXT_MAX_LENGTH);
+  });
+});

package/templates/nextblock-template/lib/seo/fix-prompts.ts

@@ -0,0 +1,204 @@
+/**
+ * Turns an SEO finding into the two strings the Cortex AI rewrite endpoint takes.
+ *
+ * The audit panel that calls this is a React component with a network call, a
+ * debounce and a Tiptap instance in it, and this repository has no DOM test
+ * environment (`@testing-library/react` is deliberately not a dependency), so
+ * the panel itself cannot be exercised by a test. Everything in it that can get
+ * the *content* of a request wrong therefore lives here instead, as ordinary
+ * functions over plain data: which issues may offer a Fix button at all, what
+ * instruction the model is given, and what it is told about the surrounding
+ * document. What is left in the component is wiring — state, fetch, insertion —
+ * which fails loudly in the browser rather than silently producing a bad prompt.
+ *
+ * The hard constraint this module exists to honour is the request schema on
+ * `POST /api/ai/generate-blocks`, which is a `z.strictObject`:
+ *
+ *   { context?: string (max 2000); prompt: string (min 3, max 4000) }
+ *
+ * Strict means an unrecognised key is a 400 with no useful message, and the
+ * length caps are enforced server-side, so both strings are clamped here rather
+ * than hoped about at the call site. Every limit below mirrors that schema; if
+ * the route's schema ever changes, these constants change with it.
+ */
+
+import type { SeoIssue } from '@nextblock-cms/utils/seo';
+
+/** Mirrors `context: z.string().max(2000)` on the generate-blocks schema. */
+export const SEO_FIX_CONTEXT_MAX_LENGTH = 2000;
+
+/** Mirrors `prompt: z.string().max(4000)` on the generate-blocks schema. */
+export const SEO_FIX_PROMPT_MAX_LENGTH = 4000;
+
+/** Mirrors `prompt: z.string().min(3)` on the generate-blocks schema. */
+export const SEO_FIX_PROMPT_MIN_LENGTH = 3;
+
+/**
+ * How much of the document body to quote back to the model.
+ *
+ * Sized so the quoted body plus the framing lines around it still fit inside
+ * `SEO_FIX_CONTEXT_MAX_LENGTH` without the final clamp having to bite, because
+ * a clamp that lands in the *middle* of the assembled context would cut the
+ * trailing sections off entirely and leave the model reading a truncated
+ * excerpt as if it were the whole page.
+ */
+export const SEO_FIX_CONTEXT_BODY_BUDGET = 1200;
+
+/** How much of the author's selection to quote when fixing a selected passage. */
+export const SEO_FIX_CONTEXT_SELECTION_BUDGET = 600;
+
+/**
+ * Where the rewritten fragment is going to land, which changes what the model
+ * should produce: a whole document, a replacement for the highlighted passage,
+ * or a continuation appended after everything that already exists.
+ *
+ * The three values match the branches the editor's own prompt bar already uses
+ * (`buildAiEditorContext` in `libs/editor/src/lib/NotionEditor.tsx`), so a
+ * one-click fix and a hand-typed prompt are framed to the model identically.
+ */
+export type SeoFixInsertionMode =
+  | 'append-to-end'
+  | 'replace-empty-document'
+  | 'replace-selection';
+
+export interface SeoFixContextInput {
+  /** Plain text of the document being audited, used to ground the rewrite. */
+  documentText: string;
+  /** Headings in document order, already formatted as e.g. `H2 Ingredients`. */
+  headingOutline?: string[];
+  insertionMode: SeoFixInsertionMode;
+  /** The text the author had highlighted, when the fix targets a selection. */
+  selectedText?: string | null;
+  /** Word count from the audit, so the model is told the real number. */
+  wordCount?: number | null;
+}
+
+export interface SeoFixPromptInput {
+  issue: SeoIssue;
+  /** The focus keyphrase, when one is set; blank and `null` are equivalent. */
+  keyword?: string | null;
+  /** Word count from the audit, quoted for the findings that are about length. */
+  wordCount?: number | null;
+}
+
+/**
+ * Cuts a string to `limit` characters without ever exceeding it.
+ *
+ * Deliberately a hard slice rather than a word-boundary trim: the caps are a
+ * server-side validation boundary, and "nearly 2000" is a rejected request. A
+ * ragged final word costs the model nothing; a 400 costs the author their click.
+ */
+function clampLength(value: string, limit: number): string {
+  return value.length <= limit ? value : value.slice(0, limit);
+}
+
+/**
+ * Whether the "Fix with Cortex AI" button should appear for this finding.
+ *
+ * Two conditions, and both matter. `fixable` is the audit engine's own verdict,
+ * and it says no to more than you might expect: a missing H1 and a missing
+ * keyphrase are unfixable because choosing them is an editorial decision, and
+ * missing image alt text is unfixable *here* because describing pixels needs the
+ * vision-backed generator in the media library rather than a prose rewrite. A
+ * non-empty `fixPrompt` is then required because it is the entire instruction
+ * handed to the model — an issue marked fixable without one would send a prompt
+ * assembled from nothing but the problem statement, and the model would answer
+ * by restating the problem instead of repairing it.
+ */
+export function canFixIssueWithCortexAi(issue: SeoIssue): boolean {
+  return issue.fixable && typeof issue.fixPrompt === 'string' && issue.fixPrompt.trim() !== '';
+}
+
+/**
+ * Builds the `prompt` field: the audit's own repair instruction, plus the
+ * concrete numbers behind the finding, plus the output contract.
+ *
+ * The numbers come from `issue.detail`, which every auditor writes as a sentence
+ * that already contains them ("This page has 118 words; 300 or more…"), so
+ * quoting it verbatim keeps the figure on screen and the figure in the request
+ * from ever drifting apart. Restating the message alongside the instruction is
+ * not redundancy: `fixPrompt` is phrased as a bare command, and a model told
+ * only "shorten the longest sentences" has no idea by how much.
+ *
+ * The output contract at the end exists because the response is inserted
+ * straight into a Tiptap document. A model that answered with a markdown code
+ * fence, a preamble, or a full HTML document would have all of that rendered as
+ * literal content in the page the author is editing.
+ */
+export function buildSeoFixPrompt(input: SeoFixPromptInput): string {
+  const { issue, keyword, wordCount } = input;
+  const instruction = (issue.fixPrompt ?? '').trim();
+  const trimmedKeyword = (keyword ?? '').trim();
+
+  const lines: Array<string | null> = [
+    instruction,
+    '',
+    `The SEO audit reported: ${issue.message}${issue.detail ? ` ${issue.detail}` : ''}`,
+    trimmedKeyword === '' ? null : `The focus keyphrase for this page is "${trimmedKeyword}".`,
+    typeof wordCount === 'number' && Number.isFinite(wordCount)
+      ? `The document currently runs to ${wordCount} words.`
+      : null,
+    '',
+    'Return only the corrected content as an HTML fragment using semantic tags such as <h2>, <p>, <ul> and <li>. Do not wrap it in a code fence, do not add commentary, and do not emit <html>, <head> or <body>.',
+  ];
+
+  const prompt = lines
+    .filter((line): line is string => line !== null)
+    .join('\n')
+    .trim();
+
+  return clampLength(prompt, SEO_FIX_PROMPT_MAX_LENGTH);
+}
+
+/**
+ * Builds the `context` field: what the model needs to know about the document
+ * it is editing, framed by where its answer is going to be inserted.
+ *
+ * This mirrors `buildAiEditorContext` in the editor's prompt bar on purpose.
+ * Both feed the same endpoint, and a fix that described the document
+ * differently from a hand-typed prompt would get systematically different
+ * output from the same model for no reason an author could see.
+ *
+ * The body excerpt is taken from the *end* of the document when appending and
+ * from the *start* otherwise, because those are the parts adjacent to where the
+ * answer lands: a continuation needs to know what it is continuing, while a
+ * rewrite anchored at the top is best grounded by the opening.
+ */
+export function buildSeoFixContext(input: SeoFixContextInput): string {
+  const { documentText, headingOutline, insertionMode, selectedText, wordCount } = input;
+
+  // An empty document has no context worth sending, and saying so is more
+  // useful to the model than an excerpt of nothing followed by an outline of
+  // nothing. This matches the editor's own early return for the same case.
+  if (insertionMode === 'replace-empty-document') {
+    return 'Insertion target: empty editor. Create the initial content for this document.';
+  }
+
+  const body = (documentText ?? '').trim();
+  const selection = (selectedText ?? '').trim();
+  const excerpt =
+    insertionMode === 'append-to-end'
+      ? body.slice(-SEO_FIX_CONTEXT_BODY_BUDGET)
+      : body.slice(0, SEO_FIX_CONTEXT_BODY_BUDGET);
+
+  const parts: Array<string | null> = [
+    `Insertion target: ${insertionMode}.`,
+    insertionMode === 'append-to-end'
+      ? 'Continue after the existing content. Do not repeat existing headings, paragraphs, or lists unless the fix explicitly calls for a rewrite.'
+      : 'Replace only the selected content. Keep the surrounding editor content in mind for continuity.',
+    typeof wordCount === 'number' && Number.isFinite(wordCount)
+      ? `The document has ${wordCount} words.`
+      : null,
+    headingOutline && headingOutline.length > 0
+      ? `Heading outline:\n${headingOutline.join('\n')}`
+      : null,
+    selection === ''
+      ? null
+      : `Selected text:\n${selection.slice(0, SEO_FIX_CONTEXT_SELECTION_BUDGET)}`,
+    excerpt === '' ? null : `Existing editor text:\n${excerpt}`,
+  ];
+
+  const context = parts.filter((part): part is string => part !== null).join('\n\n');
+
+  return clampLength(context, SEO_FIX_CONTEXT_MAX_LENGTH);
+}

package/templates/nextblock-template/lib/seo/page-audit-context.tsx

@@ -0,0 +1,140 @@
+'use client';
+
+/**
+ * Shared live state for the page-level SEO audit.
+ *
+ * WHY THIS EXISTS. The pieces an SEO audit needs are spread across three sibling
+ * components that have no relationship to each other: `BlockEditorArea` owns the
+ * live `blocks` array (it is the only client component that holds all of them),
+ * `PageForm` / `PostForm` own the meta title and description as local form state,
+ * and the panel that has to grade all of it renders next to both. Lifting any one
+ * of those into another would mean restructuring an edit screen that works; a small
+ * context is the cheaper and less invasive answer.
+ *
+ * WHY THE AUDIT IS PAGE-LEVEL AND NOT PER-BLOCK. The first version of this feature
+ * mounted the panel inside the rich-text editor, where it could only ever see one
+ * block. That produced confidently wrong results: a single paragraph block was told
+ * it had no H1 and fewer than 300 words, neither of which is a property a block can
+ * have. Headings in NextBlock live in two places — standalone `heading` blocks and
+ * h1–h6 nodes inside a `text` block's HTML — and blocks nested in a `section` live
+ * in `content.column_blocks[column][index]` rather than in the top-level array. Only
+ * something walking the whole tree can answer "does this page have exactly one H1".
+ * So the page-level panel is the real audit, and the in-editor panel is narrowed to
+ * the handful of checks a single block genuinely owns.
+ *
+ * PUBLISHING IS EFFECT-DRIVEN, deliberately. Both producers call their setter from a
+ * `useEffect` keyed on the value they publish, never during render — a child calling
+ * a parent's setState while rendering is the classic "Cannot update a component
+ * while rendering a different component" warning, and with the blocks array it would
+ * be an update loop rather than just a warning.
+ *
+ * `usePageSeo()` RETURNS NULL OUTSIDE A PROVIDER on purpose. `PageForm`,
+ * `BlockEditorArea` and `TextBlockEditor` are all reachable from surfaces that have
+ * no page-level audit — the product editor is the live example — and none of them
+ * should crash or need a second code path just because the panel is absent.
+ */
+
+import React, {
+  createContext,
+  useCallback,
+  useContext,
+  useMemo,
+  useState,
+  type ReactNode,
+} from 'react';
+
+/** Everything the page-level audit grades, as it currently stands in the editor. */
+export interface PageSeoSnapshot {
+  /**
+   * The live blocks array, exactly as `BlockEditorArea` holds it. Typed as
+   * `unknown[]` because this module has no business knowing the block union — the
+   * walker in `page-document.ts` is defensive about shape anyway, since block
+   * content is `Json` and a custom block can carry anything.
+   */
+  blocks: unknown[];
+  metaDescription: string | null;
+  metaTitle: string | null;
+}
+
+export interface PageSeoContextValue {
+  /** The focus keyphrase, held here so it survives switching between blocks. */
+  keyword: string;
+  setBlocks: (blocks: unknown[]) => void;
+  setKeyword: (keyword: string) => void;
+  setMeta: (meta: { metaDescription: string | null; metaTitle: string | null }) => void;
+  snapshot: PageSeoSnapshot;
+}
+
+const PageSeoContext = createContext<PageSeoContextValue | null>(null);
+
+export interface PageSeoProviderProps {
+  children: ReactNode;
+  initialBlocks?: unknown[];
+  initialMetaDescription?: string | null;
+  initialMetaTitle?: string | null;
+}
+
+export function PageSeoProvider({
+  children,
+  initialBlocks = [],
+  initialMetaDescription = null,
+  initialMetaTitle = null,
+}: PageSeoProviderProps) {
+  const [blocks, setBlocksState] = useState<unknown[]>(initialBlocks);
+  const [keyword, setKeyword] = useState('');
+  const [meta, setMetaState] = useState<{
+    metaDescription: string | null;
+    metaTitle: string | null;
+  }>({ metaDescription: initialMetaDescription, metaTitle: initialMetaTitle });
+
+  // Both setters bail when nothing actually changed. The blocks array is rebuilt on
+  // every keystroke in a block editor, so without the length-and-identity check
+  // below every character typed would re-render the provider and every consumer of
+  // this context, not just the panel that debounces its own work.
+  const setBlocks = useCallback((next: unknown[]) => {
+    setBlocksState((previous) =>
+      previous.length === next.length && previous.every((block, index) => block === next[index])
+        ? previous
+        : next,
+    );
+  }, []);
+
+  const setMeta = useCallback(
+    (next: { metaDescription: string | null; metaTitle: string | null }) => {
+      setMetaState((previous) =>
+        previous.metaDescription === next.metaDescription && previous.metaTitle === next.metaTitle
+          ? previous
+          : next,
+      );
+    },
+    [],
+  );
+
+  const value = useMemo<PageSeoContextValue>(
+    () => ({
+      keyword,
+      setBlocks,
+      setKeyword,
+      setMeta,
+      snapshot: {
+        blocks,
+        metaDescription: meta.metaDescription,
+        metaTitle: meta.metaTitle,
+      },
+    }),
+    [blocks, keyword, meta.metaDescription, meta.metaTitle, setBlocks, setMeta],
+  );
+
+  return <PageSeoContext.Provider value={value}>{children}</PageSeoContext.Provider>;
+}
+
+/**
+ * The page-level audit state, or `null` when there is no provider above.
+ *
+ * Callers must handle the null case rather than asserting — see the module docblock
+ * for why an edit surface without a page-level panel is a supported configuration
+ * and not a mistake.
+ */
+export function usePageSeo(): PageSeoContextValue | null {
+  return useContext(PageSeoContext);
+}