ngwr 10.2.1 → 11.0.0

package/fesm2022/ngwr-markdown-testing.mjs

@@ -0,0 +1,516 @@
+import { ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * Test harness for one fenced code block of a `<wr-markdown>` document.
+ *
+ * A block of its own rather than a field on the document harness, because it is
+ * the one piece of rendered markdown that has BEHAVIOUR: it carries a language, it
+ * may or may not be coloured yet, and it may offer a copy button — three states
+ * that belong to the block and not to the page it is on.
+ *
+ * Its host is the `.wr-markdown__code-block` wrapper, which is what holds the
+ * `<pre>` and the copy button together. Blocks nested inside a quote or a list item
+ * are blocks too, and this harness finds them: `<wr-markdown>` renders them the
+ * same way, and the copy affordance is theirs as well.
+ *
+ * @example
+ * ```ts
+ * const block = await (await loader.getHarness(WrMarkdownHarness)).getCodeBlock({ language: 'ts' });
+ *
+ * expect(await block.getCode()).toBe('const a = 1;');
+ * await block.copy();
+ * ```
+ *
+ * @see https://ngwr.dev/reference/components/markdown
+ * @see https://ngwr.dev/guides/testing
+ */
+class WrMarkdownCodeBlockHarness extends ComponentHarness {
+    static hostSelector = '.wr-markdown__code-block';
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options = {}) {
+        return new HarnessPredicate(WrMarkdownCodeBlockHarness, options)
+            .addOption('language', options.language, (harness, language) => HarnessPredicate.stringMatches(harness.getLanguage(), language))
+            .addOption('code', options.code, (harness, code) => HarnessPredicate.stringMatches(harness.getCode(), code));
+    }
+    pre = this.locatorFor('pre.wr-markdown__pre');
+    code = this.locatorFor('code.wr-markdown__code');
+    copyButton = this.locatorForOptional('button.wr-markdown__copy');
+    /**
+     * The block's language — the info string's first word, lowercased — or `null` for
+     * a bare fence.
+     *
+     * Read from `data-language`, which is the only place it reaches the DOM, and the
+     * reason it is there at all: a highlighter picks a grammar by it, and the
+     * showcase's markdown export needs it to re-fence the block. `null` is a real
+     * answer, not a gap: a bare fence names no grammar, so nothing is ever asked to
+     * colour it.
+     */
+    async getLanguage() {
+        return (await this.code()).getAttribute('data-language');
+    }
+    /**
+     * The block's code, EXACTLY — every space, every blank line, every newline.
+     *
+     * Nothing is collapsed here, unlike every prose read on the document harness,
+     * and it is read off the `<pre>` rather than off the host so the copy button is
+     * not part of the answer. Two failures live in this one string. Angular strips
+     * whitespace-only text nodes from templates, so the code has to arrive as an
+     * interpolation — a template that types it instead loses the indentation. And a
+     * HIGHLIGHTED block is not one text node but a span per token: what separates its
+     * lines is a real `\n` interpolated between them, so a spec that only ever
+     * asserts the unhighlighted case would not notice a highlighted block copying out
+     * as one run-together line.
+     */
+    async getCode() {
+        return (await (await this.pre()).getProperty('textContent')) ?? '';
+    }
+    /**
+     * Whether the block is coloured right now.
+     *
+     * A block is plain text until a highlighter answers for it, and that is the
+     * intended order rather than a compromise: a grammar engine loads WASM, and
+     * blocking on it would leave the reader with an empty box instead of their code.
+     * So this is `false` with no `WR_MARKDOWN_HIGHLIGHTER` provided, `false` for a
+     * language the highlighter declined or threw on, `false` under SSR — a
+     * highlighter resolving after prerender cannot contribute to the HTML — and
+     * `false` for the first render of an async one.
+     */
+    async isHighlighted() {
+        return (await this.locatorForOptional('.wr-markdown__line')()) !== null;
+    }
+    /**
+     * Whether this block offers a copy button.
+     *
+     * Two conditions, and both are the component's policy rather than an accident:
+     * `copyable` has to be on (bound, or defaulted through
+     * `provideWrConfig({ markdown: { copyable: true } })`), and the fence has to be
+     * CLOSED. Mid-stream a block's code is not all there, and a button that copies
+     * half a snippet is worse than no button.
+     */
+    async canCopy() {
+        return (await this.copyButton()) !== null;
+    }
+    /**
+     * The copy button's accessible name, or `null` when there is no button.
+     *
+     * Worth reading rather than assuming, because it is the whole of the copy
+     * feedback: the button swaps its label — and its icon — for the "copied" one for
+     * two seconds after a successful write, and both strings come from the i18n
+     * catalog (`markdown.copy` / `markdown.copied`) or the matching inputs. Which is
+     * also why this harness reports the name instead of a `isCopied()` boolean: only
+     * the consuming app knows which of its own two strings means which.
+     */
+    async getCopyLabel() {
+        const button = await this.copyButton();
+        return button ? button.getAttribute('aria-label') : null;
+    }
+    /**
+     * Copy the block, the way a pointer does.
+     *
+     * Throws when there is no button, naming both reasons — a silent no-op here
+     * surfaces as an empty clipboard assertion several lines later. Note what a
+     * successful click needs from the environment: the directive behind the button
+     * writes through `navigator.clipboard`, which jsdom does not implement at all, so
+     * a unit test has to stand one in before the write can succeed and the label can
+     * swap.
+     */
+    async copy() {
+        const button = await this.copyButton();
+        if (!button) {
+            throw new Error('WrMarkdownCodeBlockHarness.copy(): this block has no copy button. Either `copyable` is off — it ' +
+                'falls back to `markdown.copyable` from provideWrConfig(), then to false — or the fence is still ' +
+                'open, and <wr-markdown> only offers one on a CLOSED block.');
+        }
+        await button.click();
+    }
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * Collapse the whitespace of a prose read to the line a reader sees.
+ *
+ * `TestElement.text()` only trims the ends, and markdown prose is never one text
+ * node: a paragraph is text spliced with `<strong>`, `<code>` and `<a>`, and a
+ * SOFT line break inside it is rendered as a real `\n` — the parser keeps it as
+ * whitespace and lets CSS collapse it, which is what CommonMark asks for. Reading
+ * `textContent` raw therefore reports a paragraph the author wrote on three lines
+ * as three lines, while the browser shows one; every run becomes a single space so
+ * a spec can assert what is on screen.
+ *
+ * Deliberately NOT used on a code block. There the whitespace IS the content —
+ * indentation, blank lines, the newlines between highlighted lines — so
+ * `WrMarkdownCodeBlockHarness.getCode()` reads it exactly and this function never
+ * touches it.
+ */
+function wrMarkdownHarnessText(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * The task-state label — hidden from the page, read out in front of the item.
+ *
+ * Left out of every prose read here, so a spec asserting an item's text does not
+ * have to know that `'Done: '` is spliced in front of it. It is not lost: it is a
+ * field of its own on {@link WrMarkdownHarnessTaskItem}, which is where its
+ * absence is a failure rather than a nuisance.
+ */
+const SR_ONLY = '.wr-markdown__sr-only';
+/** The alignment the renderer wrote as an inline style, if it wrote one. */
+const TEXT_ALIGN_RE = /text-align:\s*([a-z]+)/;
+/** Every prose read goes through here: collapsed, and without the hidden labels. */
+async function proseText(element) {
+    return wrMarkdownHarnessText(await element.text({ exclude: SR_ONLY }));
+}
+/**
+ * A cell's or a header's alignment, read off the inline `style` attribute.
+ *
+ * Not through `getCssValue()`, and the difference is not cosmetic: a column the
+ * delimiter row said nothing about carries no declaration at all, and computed
+ * style answers for it anyway — with whatever the user-agent stylesheet says a
+ * `<th>` or a `<td>` is aligned to. That makes "no alignment" indistinguishable
+ * from `center`, in the one direction that matters (a `<th>` centres by default),
+ * and it makes the answer depend on the browser rather than on the document. The
+ * attribute is what the component wrote, which is the fact being asserted.
+ */
+async function alignOf(cell) {
+    const match = TEXT_ALIGN_RE.exec((await cell.getAttribute('style')) ?? '');
+    switch (match?.[1]) {
+        case 'start':
+            return 'start';
+        case 'center':
+            return 'center';
+        case 'end':
+            return 'end';
+        default:
+            return null;
+    }
+}
+/**
+ * One body row of a rendered table.
+ *
+ * Not exported, and not because rows do not matter: a `TestElement` cannot be
+ * queried INTO, so reading one row's own cells needs a harness rooted on that row.
+ * Nothing here is drivable — rendered prose is inert — so the row's job is to hand
+ * its cells up to {@link WrMarkdownHarness.getTables}, which is where a consumer
+ * asserts the whole table in one comparison.
+ */
+class WrMarkdownTableRowReader extends ComponentHarness {
+    /** Body rows only: the header row lives in the `<thead>`. */
+    static hostSelector = 'tbody tr';
+    async getCellTexts() {
+        const cells = await this.locatorForAll('.wr-markdown__td')();
+        return Promise.all(cells.map(cell => proseText(cell)));
+    }
+}
+/**
+ * One rendered task-list item — a harness for the same reason as the row reader.
+ *
+ * Its three reads have to be SCOPED to the item: querying the tick and the hidden
+ * label from the document root would hand every item in the document the first
+ * one's state, which is the kind of green spec that reports a broken checklist as
+ * intact. A nested task list lives inside its parent `<li>`, and the parent's own
+ * tick and label are rendered before it — so the first match under an item is
+ * always the item's own.
+ */
+class WrMarkdownTaskItemReader extends ComponentHarness {
+    static hostSelector = '.wr-markdown__item--task';
+    tick = this.locatorForOptional('.wr-markdown__task--checked');
+    stateLabel = this.locatorForOptional(SR_ONLY);
+    async read() {
+        const label = await this.stateLabel();
+        return {
+            text: await proseText(await this.host()),
+            checked: (await this.tick()) !== null,
+            stateLabel: label ? await label.text() : null,
+        };
+    }
+}
+/** One rendered table — see {@link WrMarkdownTableRowReader} for why this is a harness. */
+class WrMarkdownTableReader extends ComponentHarness {
+    static hostSelector = 'table.wr-markdown__table';
+    async read() {
+        const headers = await this.locatorForAll('th.wr-markdown__th')();
+        const rows = await this.locatorForAll(WrMarkdownTableRowReader)();
+        return {
+            headers: await Promise.all(headers.map(header => proseText(header))),
+            rows: await Promise.all(rows.map(row => row.getCellTexts())),
+            align: await Promise.all(headers.map(header => alignOf(header))),
+        };
+    }
+}
+/**
+ * Test harness for `<wr-markdown>`, with {@link WrMarkdownCodeBlockHarness} for one
+ * fenced code block.
+ *
+ * What a consumer of a markdown renderer actually asserts is that a piece of
+ * SOURCE became the right DOM, so everything here reads rendered elements: the
+ * heading levels, the `href` / `target` / `rel` triple on a link, the tick state of
+ * a task item, a table as a rectangle of text. The parse tree is not exposed on
+ * purpose — `parseMarkdown()` is a pure function with its own spec, and a harness
+ * that reported its nodes would pass straight through the half that breaks people,
+ * which is the template between the tree and the page.
+ *
+ * Three things worth knowing before writing expectations:
+ *
+ * - **Prose reads are whitespace-collapsed, code is not.** A soft line break inside
+ *   a paragraph is a real `\n` in the DOM (CommonMark says CSS collapses it), so
+ *   every text answer here is normalized to the line a reader sees.
+ *   {@link WrMarkdownCodeBlockHarness.getCode} is the exception and reads its
+ *   snippet exactly.
+ * - **The hidden task-state labels are left out of prose.** They are announced text,
+ *   not visible text; {@link getTaskItems} reports them as a field.
+ * - **Everything is flat and in document order.** Markdown nests — a quote holds
+ *   blocks, a list item holds blocks — and these readers do not re-derive that
+ *   hierarchy: {@link getCodeBlocks} finds a block inside a quote, and a nested
+ *   list item's text is part of its parent's, because that is what the DOM says.
+ *
+ * @example
+ * ```ts
+ * const md = await loader.getHarness(WrMarkdownHarness);
+ *
+ * expect(await md.getHeadings()).toEqual([{ level: 1, text: 'Release notes', id: 'release-notes' }]);
+ * expect(await md.getLinks()).toEqual([
+ *   { text: 'the docs', href: 'https://ngwr.dev', title: null, target: '_blank', rel: 'noopener noreferrer' },
+ * ]);
+ * ```
+ *
+ * @see https://ngwr.dev/reference/components/markdown
+ * @see https://ngwr.dev/guides/testing
+ */
+class WrMarkdownHarness extends ComponentHarness {
+    static hostSelector = 'wr-markdown';
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options = {}) {
+        return new HarnessPredicate(WrMarkdownHarness, options)
+            .addOption('text', options.text, (harness, text) => HarnessPredicate.stringMatches(harness.getText(), text))
+            .addOption('headingText', options.headingText, async (harness, text) => {
+            for (const heading of await harness.getHeadings()) {
+                if (await HarnessPredicate.stringMatches(heading.text, text))
+                    return true;
+            }
+            return false;
+        })
+            .addOption('codeLanguage', options.codeLanguage, async (harness, language) => {
+            for (const block of await harness.getCodeBlocks()) {
+                if (await HarnessPredicate.stringMatches(block.getLanguage(), language))
+                    return true;
+            }
+            return false;
+        })
+            .addOption('streaming', options.streaming, async (harness, streaming) => (await harness.isStreaming()) === streaming);
+    }
+    /**
+     * The whole document as text — whitespace collapsed, the hidden task-state labels
+     * left out.
+     *
+     * The coarse read, and the useful one for the security cases: raw HTML in the
+     * source is ESCAPED rather than rendered, so `<img onerror=…>` shows up here as
+     * characters, and a refused `javascript:` URL leaves its label behind as text with
+     * no anchor around it. A code block's newlines are collapsed like everything else
+     * — {@link getCodeBlocks} is where a snippet stays exact.
+     *
+     * It is `textContent`, which means sibling BLOCKS are not separated: a document of
+     * `<h1>Title</h1><p>Body</p>` reads as `'TitleBody'`, because the renderer emits
+     * no whitespace between them and none is invented here. Assert a fragment with
+     * `toContain`, or read the blocks themselves — {@link getHeadings},
+     * {@link getParagraphs} — when the boundary matters.
+     */
+    async getText() {
+        return proseText(await this.host());
+    }
+    /**
+     * Whether the component rendered nothing at all.
+     *
+     * True for an empty `value`, and for one that parses to nothing — a lone `<!--`
+     * or whitespace. Distinct from `getText() === ''`, which a document made only of
+     * a thematic break or an image would also answer.
+     */
+    async isEmpty() {
+        const host = await this.host();
+        if ((await host.getProperty('childElementCount')) > 0)
+            return false;
+        return (await this.getText()) === '';
+    }
+    /**
+     * Whether the document is being streamed.
+     *
+     * Read from the `--streaming` host modifier rather than from the input, because
+     * the modifier is the whole public API of the feature on the styling side: it is
+     * what paints the caret after the last block. What it does NOT say is that
+     * partial-safe parsing is on — the same input drives both, but only this reaches
+     * the DOM.
+     */
+    async isStreaming() {
+        return (await this.host()).hasClass('wr-markdown--streaming');
+    }
+    /** Every heading, in document order. */
+    async getHeadings() {
+        const headings = await this.locatorForAll('.wr-markdown__heading')();
+        return Promise.all(headings.map(async (heading) => ({
+            // `H3` → 3. The element is where the level lives; see the field's docs.
+            level: Number.parseInt((await heading.getProperty('tagName')).slice(1), 10),
+            text: await proseText(heading),
+            id: await heading.getAttribute('id'),
+        })));
+    }
+    /**
+     * The text of every paragraph, in document order.
+     *
+     * Including the ones inside a LOOSE list item — CommonMark drops the `<p>` in a
+     * tight list and keeps it in a loose one, which is what stops a one-line list from
+     * rendering double-spaced, so an empty answer for `- a\n- b` is the correct one
+     * rather than a missed paragraph.
+     */
+    async getParagraphs() {
+        const paragraphs = await this.locatorForAll('.wr-markdown__paragraph')();
+        return Promise.all(paragraphs.map(paragraph => proseText(paragraph)));
+    }
+    /**
+     * Every link, in document order, with the attributes that make it safe.
+     *
+     * A URL the renderer refused is NOT here — it renders as plain text instead of as
+     * a live anchor that announces as a link and does nothing — so an empty answer
+     * where a link was expected is the sanitizer speaking, and {@link getText} still
+     * has the label.
+     */
+    async getLinks() {
+        const links = await this.locatorForAll('.wr-markdown__link')();
+        return Promise.all(links.map(async (link) => ({
+            text: await proseText(link),
+            href: await link.getAttribute('href'),
+            title: await link.getAttribute('title'),
+            target: await link.getAttribute('target'),
+            rel: await link.getAttribute('rel'),
+        })));
+    }
+    /**
+     * Every image, in document order.
+     *
+     * A refused source renders no image at all and leaves the alt text as prose,
+     * which is the information the author actually wrote — so assert this together
+     * with {@link getText} when the point is the refusal.
+     */
+    async getImages() {
+        const images = await this.locatorForAll('.wr-markdown__image')();
+        return Promise.all(images.map(async (image) => ({
+            src: await image.getAttribute('src'),
+            alt: await image.getAttribute('alt'),
+            title: await image.getAttribute('title'),
+        })));
+    }
+    /**
+     * The text of every inline code span, in document order.
+     *
+     * A different element from a fenced block (`<code>` on its own, not inside a
+     * `<pre>`), and never one of {@link getCodeBlocks}. Read exactly rather than
+     * collapsed, for the same reason a block is: this is code, and the spacing in it
+     * is content.
+     */
+    async getInlineCode() {
+        const spans = await this.locatorForAll('.wr-markdown__code-inline')();
+        return Promise.all(spans.map(async (span) => (await span.getProperty('textContent')) ?? ''));
+    }
+    /**
+     * The fenced code blocks, in document order — nested ones included.
+     *
+     * A block inside a quote or a list item is a block: it renders the same way and it
+     * gets the same copy affordance, so leaving it out would report a document as
+     * having no code because its snippet is indented under a bullet.
+     */
+    async getCodeBlocks(filters = {}) {
+        return this.locatorForAll(WrMarkdownCodeBlockHarness.with(filters))();
+    }
+    /**
+     * The first code block matching the filters.
+     *
+     * Throws when nothing matches, naming the languages the document does offer —
+     * a `getCodeBlocks(…)[0]` that quietly resolves to `undefined` fails several lines
+     * later, on an unrelated line, with `Cannot read properties of undefined`.
+     */
+    async getCodeBlock(filters = {}) {
+        const [block] = await this.getCodeBlocks(filters);
+        if (block)
+            return block;
+        const languages = await Promise.all((await this.getCodeBlocks()).map(other => other.getLanguage()));
+        const offered = languages.length > 0
+            ? `This document has ${languages.length} block(s), in: ${languages.map(name => name ?? '(none)').join(', ')}.`
+            : 'This document renders no code blocks at all.';
+        throw new Error(`WrMarkdownHarness.getCodeBlock(): no block matched ${JSON.stringify(filters)}. ${offered}`);
+    }
+    /**
+     * The text of every list item, in document order.
+     *
+     * Bullets, numbers and task items alike — a task item's tick state is in
+     * {@link getTaskItems} instead. NESTING is not re-derived: a nested list lives
+     * INSIDE its parent `<li>` (which is what makes the list's accessibility tree
+     * valid), so a parent's text contains its children's, and each child is also an
+     * entry of its own.
+     */
+    async getListItems() {
+        const items = await this.locatorForAll('.wr-markdown__item')();
+        return Promise.all(items.map(item => proseText(item)));
+    }
+    /**
+     * Every task-list item (`- [x]` / `- [ ]`), in document order.
+     *
+     * Ordinary items are not here, so the count is the number of checkboxes in the
+     * document. Both halves of each entry are worth asserting: the `checked` flag is
+     * what a reader sees, and `stateLabel` is the only thing a screen reader gets —
+     * the tick itself is `aria-hidden`.
+     */
+    async getTaskItems() {
+        const items = await this.locatorForAll(WrMarkdownTaskItemReader)();
+        return Promise.all(items.map(item => item.read()));
+    }
+    /** Every table, in document order, each as a rectangle of text plus its alignment. */
+    async getTables() {
+        const tables = await this.locatorForAll(WrMarkdownTableReader)();
+        return Promise.all(tables.map(table => table.read()));
+    }
+    /**
+     * The text of every blockquote, in document order.
+     *
+     * A quote holds BLOCKS, so this is everything inside it collapsed to one line —
+     * its paragraphs are also in {@link getParagraphs} and a snippet inside it is
+     * also one of {@link getCodeBlocks}.
+     */
+    async getQuotes() {
+        const quotes = await this.locatorForAll('.wr-markdown__quote')();
+        return Promise.all(quotes.map(quote => proseText(quote)));
+    }
+    /**
+     * How many thematic breaks the document rendered.
+     *
+     * A count rather than a list because an `<hr>` has no content — and it is worth
+     * counting: `---` is the one construct this renderer resolves differently from
+     * some others (it is always a break here, never a setext heading underline), so a
+     * document that lost a rule gained a heading somewhere.
+     */
+    async getRuleCount() {
+        return (await this.locatorForAll('.wr-markdown__rule')()).length;
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { WrMarkdownCodeBlockHarness, WrMarkdownHarness };
+//# sourceMappingURL=ngwr-markdown-testing.mjs.map

package/fesm2022/ngwr-markdown-testing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ngwr-markdown-testing.mjs","sources":["../../../projects/lib/markdown/testing/wr-markdown-code-block-harness.ts","../../../projects/lib/markdown/testing/wr-markdown-harness-text.ts","../../../projects/lib/markdown/testing/wr-markdown-harness.ts","../../../projects/lib/markdown/testing/ngwr-markdown-testing.ts"],"sourcesContent":["/**\n * @license\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE\n */\n\nimport { ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';\n\nimport type { WrMarkdownCodeBlockHarnessFilters } from './interfaces';\n\n/**\n * Test harness for one fenced code block of a `<wr-markdown>` document.\n *\n * A block of its own rather than a field on the document harness, because it is\n * the one piece of rendered markdown that has BEHAVIOUR: it carries a language, it\n * may or may not be coloured yet, and it may offer a copy button — three states\n * that belong to the block and not to the page it is on.\n *\n * Its host is the `.wr-markdown__code-block` wrapper, which is what holds the\n * `<pre>` and the copy button together. Blocks nested inside a quote or a list item\n * are blocks too, and this harness finds them: `<wr-markdown>` renders them the\n * same way, and the copy affordance is theirs as well.\n *\n * @example\n * ```ts\n * const block = await (await loader.getHarness(WrMarkdownHarness)).getCodeBlock({ language: 'ts' });\n *\n * expect(await block.getCode()).toBe('const a = 1;');\n * await block.copy();\n * ```\n *\n * @see https://ngwr.dev/reference/components/markdown\n * @see https://ngwr.dev/guides/testing\n */\nexport class WrMarkdownCodeBlockHarness extends ComponentHarness {\n  static hostSelector = '.wr-markdown__code-block';\n\n  /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */\n  static with(options: WrMarkdownCodeBlockHarnessFilters = {}): HarnessPredicate<WrMarkdownCodeBlockHarness> {\n    return new HarnessPredicate(WrMarkdownCodeBlockHarness, options)\n      .addOption('language', options.language, (harness, language) =>\n        HarnessPredicate.stringMatches(harness.getLanguage(), language)\n      )\n      .addOption('code', options.code, (harness, code) => HarnessPredicate.stringMatches(harness.getCode(), code));\n  }\n\n  private readonly pre = this.locatorFor('pre.wr-markdown__pre');\n  private readonly code = this.locatorFor('code.wr-markdown__code');\n  private readonly copyButton = this.locatorForOptional('button.wr-markdown__copy');\n\n  /**\n   * The block's language — the info string's first word, lowercased — or `null` for\n   * a bare fence.\n   *\n   * Read from `data-language`, which is the only place it reaches the DOM, and the\n   * reason it is there at all: a highlighter picks a grammar by it, and the\n   * showcase's markdown export needs it to re-fence the block. `null` is a real\n   * answer, not a gap: a bare fence names no grammar, so nothing is ever asked to\n   * colour it.\n   */\n  async getLanguage(): Promise<string | null> {\n    return (await this.code()).getAttribute('data-language');\n  }\n\n  /**\n   * The block's code, EXACTLY — every space, every blank line, every newline.\n   *\n   * Nothing is collapsed here, unlike every prose read on the document harness,\n   * and it is read off the `<pre>` rather than off the host so the copy button is\n   * not part of the answer. Two failures live in this one string. Angular strips\n   * whitespace-only text nodes from templates, so the code has to arrive as an\n   * interpolation — a template that types it instead loses the indentation. And a\n   * HIGHLIGHTED block is not one text node but a span per token: what separates its\n   * lines is a real `\\n` interpolated between them, so a spec that only ever\n   * asserts the unhighlighted case would not notice a highlighted block copying out\n   * as one run-together line.\n   */\n  async getCode(): Promise<string> {\n    return (await (await this.pre()).getProperty<string | null>('textContent')) ?? '';\n  }\n\n  /**\n   * Whether the block is coloured right now.\n   *\n   * A block is plain text until a highlighter answers for it, and that is the\n   * intended order rather than a compromise: a grammar engine loads WASM, and\n   * blocking on it would leave the reader with an empty box instead of their code.\n   * So this is `false` with no `WR_MARKDOWN_HIGHLIGHTER` provided, `false` for a\n   * language the highlighter declined or threw on, `false` under SSR — a\n   * highlighter resolving after prerender cannot contribute to the HTML — and\n   * `false` for the first render of an async one.\n   */\n  async isHighlighted(): Promise<boolean> {\n    return (await this.locatorForOptional('.wr-markdown__line')()) !== null;\n  }\n\n  /**\n   * Whether this block offers a copy button.\n   *\n   * Two conditions, and both are the component's policy rather than an accident:\n   * `copyable` has to be on (bound, or defaulted through\n   * `provideWrConfig({ markdown: { copyable: true } })`), and the fence has to be\n   * CLOSED. Mid-stream a block's code is not all there, and a button that copies\n   * half a snippet is worse than no button.\n   */\n  async canCopy(): Promise<boolean> {\n    return (await this.copyButton()) !== null;\n  }\n\n  /**\n   * The copy button's accessible name, or `null` when there is no button.\n   *\n   * Worth reading rather than assuming, because it is the whole of the copy\n   * feedback: the button swaps its label — and its icon — for the \"copied\" one for\n   * two seconds after a successful write, and both strings come from the i18n\n   * catalog (`markdown.copy` / `markdown.copied`) or the matching inputs. Which is\n   * also why this harness reports the name instead of a `isCopied()` boolean: only\n   * the consuming app knows which of its own two strings means which.\n   */\n  async getCopyLabel(): Promise<string | null> {\n    const button = await this.copyButton();\n    return button ? button.getAttribute('aria-label') : null;\n  }\n\n  /**\n   * Copy the block, the way a pointer does.\n   *\n   * Throws when there is no button, naming both reasons — a silent no-op here\n   * surfaces as an empty clipboard assertion several lines later. Note what a\n   * successful click needs from the environment: the directive behind the button\n   * writes through `navigator.clipboard`, which jsdom does not implement at all, so\n   * a unit test has to stand one in before the write can succeed and the label can\n   * swap.\n   */\n  async copy(): Promise<void> {\n    const button = await this.copyButton();\n    if (!button) {\n      throw new Error(\n        'WrMarkdownCodeBlockHarness.copy(): this block has no copy button. Either `copyable` is off — it ' +\n          'falls back to `markdown.copyable` from provideWrConfig(), then to false — or the fence is still ' +\n          'open, and <wr-markdown> only offers one on a CLOSED block.'\n      );\n    }\n    await button.click();\n  }\n}\n","/**\n * @license\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE\n */\n\n/**\n * Collapse the whitespace of a prose read to the line a reader sees.\n *\n * `TestElement.text()` only trims the ends, and markdown prose is never one text\n * node: a paragraph is text spliced with `<strong>`, `<code>` and `<a>`, and a\n * SOFT line break inside it is rendered as a real `\\n` — the parser keeps it as\n * whitespace and lets CSS collapse it, which is what CommonMark asks for. Reading\n * `textContent` raw therefore reports a paragraph the author wrote on three lines\n * as three lines, while the browser shows one; every run becomes a single space so\n * a spec can assert what is on screen.\n *\n * Deliberately NOT used on a code block. There the whitespace IS the content —\n * indentation, blank lines, the newlines between highlighted lines — so\n * `WrMarkdownCodeBlockHarness.getCode()` reads it exactly and this function never\n * touches it.\n */\nexport function wrMarkdownHarnessText(text: string): string {\n  return text.replace(/\\s+/g, ' ').trim();\n}\n","/**\n * @license\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE\n */\n\nimport { ComponentHarness, HarnessPredicate, type TestElement } from '@angular/cdk/testing';\n\nimport type {\n  WrMarkdownCodeBlockHarnessFilters,\n  WrMarkdownHarnessAlign,\n  WrMarkdownHarnessFilters,\n  WrMarkdownHarnessHeading,\n  WrMarkdownHarnessImage,\n  WrMarkdownHarnessLink,\n  WrMarkdownHarnessTable,\n  WrMarkdownHarnessTaskItem,\n} from './interfaces';\nimport { WrMarkdownCodeBlockHarness } from './wr-markdown-code-block-harness';\nimport { wrMarkdownHarnessText } from './wr-markdown-harness-text';\n\n/**\n * The task-state label — hidden from the page, read out in front of the item.\n *\n * Left out of every prose read here, so a spec asserting an item's text does not\n * have to know that `'Done: '` is spliced in front of it. It is not lost: it is a\n * field of its own on {@link WrMarkdownHarnessTaskItem}, which is where its\n * absence is a failure rather than a nuisance.\n */\nconst SR_ONLY = '.wr-markdown__sr-only';\n\n/** The alignment the renderer wrote as an inline style, if it wrote one. */\nconst TEXT_ALIGN_RE = /text-align:\\s*([a-z]+)/;\n\n/** Every prose read goes through here: collapsed, and without the hidden labels. */\nasync function proseText(element: TestElement): Promise<string> {\n  return wrMarkdownHarnessText(await element.text({ exclude: SR_ONLY }));\n}\n\n/**\n * A cell's or a header's alignment, read off the inline `style` attribute.\n *\n * Not through `getCssValue()`, and the difference is not cosmetic: a column the\n * delimiter row said nothing about carries no declaration at all, and computed\n * style answers for it anyway — with whatever the user-agent stylesheet says a\n * `<th>` or a `<td>` is aligned to. That makes \"no alignment\" indistinguishable\n * from `center`, in the one direction that matters (a `<th>` centres by default),\n * and it makes the answer depend on the browser rather than on the document. The\n * attribute is what the component wrote, which is the fact being asserted.\n */\nasync function alignOf(cell: TestElement): Promise<WrMarkdownHarnessAlign> {\n  const match = TEXT_ALIGN_RE.exec((await cell.getAttribute('style')) ?? '');\n\n  switch (match?.[1]) {\n    case 'start':\n      return 'start';\n    case 'center':\n      return 'center';\n    case 'end':\n      return 'end';\n    default:\n      return null;\n  }\n}\n\n/**\n * One body row of a rendered table.\n *\n * Not exported, and not because rows do not matter: a `TestElement` cannot be\n * queried INTO, so reading one row's own cells needs a harness rooted on that row.\n * Nothing here is drivable — rendered prose is inert — so the row's job is to hand\n * its cells up to {@link WrMarkdownHarness.getTables}, which is where a consumer\n * asserts the whole table in one comparison.\n */\nclass WrMarkdownTableRowReader extends ComponentHarness {\n  /** Body rows only: the header row lives in the `<thead>`. */\n  static hostSelector = 'tbody tr';\n\n  async getCellTexts(): Promise<string[]> {\n    const cells = await this.locatorForAll('.wr-markdown__td')();\n    return Promise.all(cells.map(cell => proseText(cell)));\n  }\n}\n\n/**\n * One rendered task-list item — a harness for the same reason as the row reader.\n *\n * Its three reads have to be SCOPED to the item: querying the tick and the hidden\n * label from the document root would hand every item in the document the first\n * one's state, which is the kind of green spec that reports a broken checklist as\n * intact. A nested task list lives inside its parent `<li>`, and the parent's own\n * tick and label are rendered before it — so the first match under an item is\n * always the item's own.\n */\nclass WrMarkdownTaskItemReader extends ComponentHarness {\n  static hostSelector = '.wr-markdown__item--task';\n\n  private readonly tick = this.locatorForOptional('.wr-markdown__task--checked');\n  private readonly stateLabel = this.locatorForOptional(SR_ONLY);\n\n  async read(): Promise<WrMarkdownHarnessTaskItem> {\n    const label = await this.stateLabel();\n\n    return {\n      text: await proseText(await this.host()),\n      checked: (await this.tick()) !== null,\n      stateLabel: label ? await label.text() : null,\n    };\n  }\n}\n\n/** One rendered table — see {@link WrMarkdownTableRowReader} for why this is a harness. */\nclass WrMarkdownTableReader extends ComponentHarness {\n  static hostSelector = 'table.wr-markdown__table';\n\n  async read(): Promise<WrMarkdownHarnessTable> {\n    const headers = await this.locatorForAll('th.wr-markdown__th')();\n    const rows = await this.locatorForAll(WrMarkdownTableRowReader)();\n\n    return {\n      headers: await Promise.all(headers.map(header => proseText(header))),\n      rows: await Promise.all(rows.map(row => row.getCellTexts())),\n      align: await Promise.all(headers.map(header => alignOf(header))),\n    };\n  }\n}\n\n/**\n * Test harness for `<wr-markdown>`, with {@link WrMarkdownCodeBlockHarness} for one\n * fenced code block.\n *\n * What a consumer of a markdown renderer actually asserts is that a piece of\n * SOURCE became the right DOM, so everything here reads rendered elements: the\n * heading levels, the `href` / `target` / `rel` triple on a link, the tick state of\n * a task item, a table as a rectangle of text. The parse tree is not exposed on\n * purpose — `parseMarkdown()` is a pure function with its own spec, and a harness\n * that reported its nodes would pass straight through the half that breaks people,\n * which is the template between the tree and the page.\n *\n * Three things worth knowing before writing expectations:\n *\n * - **Prose reads are whitespace-collapsed, code is not.** A soft line break inside\n *   a paragraph is a real `\\n` in the DOM (CommonMark says CSS collapses it), so\n *   every text answer here is normalized to the line a reader sees.\n *   {@link WrMarkdownCodeBlockHarness.getCode} is the exception and reads its\n *   snippet exactly.\n * - **The hidden task-state labels are left out of prose.** They are announced text,\n *   not visible text; {@link getTaskItems} reports them as a field.\n * - **Everything is flat and in document order.** Markdown nests — a quote holds\n *   blocks, a list item holds blocks — and these readers do not re-derive that\n *   hierarchy: {@link getCodeBlocks} finds a block inside a quote, and a nested\n *   list item's text is part of its parent's, because that is what the DOM says.\n *\n * @example\n * ```ts\n * const md = await loader.getHarness(WrMarkdownHarness);\n *\n * expect(await md.getHeadings()).toEqual([{ level: 1, text: 'Release notes', id: 'release-notes' }]);\n * expect(await md.getLinks()).toEqual([\n *   { text: 'the docs', href: 'https://ngwr.dev', title: null, target: '_blank', rel: 'noopener noreferrer' },\n * ]);\n * ```\n *\n * @see https://ngwr.dev/reference/components/markdown\n * @see https://ngwr.dev/guides/testing\n */\nexport class WrMarkdownHarness extends ComponentHarness {\n  static hostSelector = 'wr-markdown';\n\n  /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */\n  static with(options: WrMarkdownHarnessFilters = {}): HarnessPredicate<WrMarkdownHarness> {\n    return new HarnessPredicate(WrMarkdownHarness, options)\n      .addOption('text', options.text, (harness, text) => HarnessPredicate.stringMatches(harness.getText(), text))\n      .addOption('headingText', options.headingText, async (harness, text) => {\n        for (const heading of await harness.getHeadings()) {\n          if (await HarnessPredicate.stringMatches(heading.text, text)) return true;\n        }\n        return false;\n      })\n      .addOption('codeLanguage', options.codeLanguage, async (harness, language) => {\n        for (const block of await harness.getCodeBlocks()) {\n          if (await HarnessPredicate.stringMatches(block.getLanguage(), language)) return true;\n        }\n        return false;\n      })\n      .addOption(\n        'streaming',\n        options.streaming,\n        async (harness, streaming) => (await harness.isStreaming()) === streaming\n      );\n  }\n\n  /**\n   * The whole document as text — whitespace collapsed, the hidden task-state labels\n   * left out.\n   *\n   * The coarse read, and the useful one for the security cases: raw HTML in the\n   * source is ESCAPED rather than rendered, so `<img onerror=…>` shows up here as\n   * characters, and a refused `javascript:` URL leaves its label behind as text with\n   * no anchor around it. A code block's newlines are collapsed like everything else\n   * — {@link getCodeBlocks} is where a snippet stays exact.\n   *\n   * It is `textContent`, which means sibling BLOCKS are not separated: a document of\n   * `<h1>Title</h1><p>Body</p>` reads as `'TitleBody'`, because the renderer emits\n   * no whitespace between them and none is invented here. Assert a fragment with\n   * `toContain`, or read the blocks themselves — {@link getHeadings},\n   * {@link getParagraphs} — when the boundary matters.\n   */\n  async getText(): Promise<string> {\n    return proseText(await this.host());\n  }\n\n  /**\n   * Whether the component rendered nothing at all.\n   *\n   * True for an empty `value`, and for one that parses to nothing — a lone `<!--`\n   * or whitespace. Distinct from `getText() === ''`, which a document made only of\n   * a thematic break or an image would also answer.\n   */\n  async isEmpty(): Promise<boolean> {\n    const host = await this.host();\n    if ((await host.getProperty<number>('childElementCount')) > 0) return false;\n    return (await this.getText()) === '';\n  }\n\n  /**\n   * Whether the document is being streamed.\n   *\n   * Read from the `--streaming` host modifier rather than from the input, because\n   * the modifier is the whole public API of the feature on the styling side: it is\n   * what paints the caret after the last block. What it does NOT say is that\n   * partial-safe parsing is on — the same input drives both, but only this reaches\n   * the DOM.\n   */\n  async isStreaming(): Promise<boolean> {\n    return (await this.host()).hasClass('wr-markdown--streaming');\n  }\n\n  /** Every heading, in document order. */\n  async getHeadings(): Promise<WrMarkdownHarnessHeading[]> {\n    const headings = await this.locatorForAll('.wr-markdown__heading')();\n\n    return Promise.all(\n      headings.map(async heading => ({\n        // `H3` → 3. The element is where the level lives; see the field's docs.\n        level: Number.parseInt((await heading.getProperty<string>('tagName')).slice(1), 10),\n        text: await proseText(heading),\n        id: await heading.getAttribute('id'),\n      }))\n    );\n  }\n\n  /**\n   * The text of every paragraph, in document order.\n   *\n   * Including the ones inside a LOOSE list item — CommonMark drops the `<p>` in a\n   * tight list and keeps it in a loose one, which is what stops a one-line list from\n   * rendering double-spaced, so an empty answer for `- a\\n- b` is the correct one\n   * rather than a missed paragraph.\n   */\n  async getParagraphs(): Promise<string[]> {\n    const paragraphs = await this.locatorForAll('.wr-markdown__paragraph')();\n    return Promise.all(paragraphs.map(paragraph => proseText(paragraph)));\n  }\n\n  /**\n   * Every link, in document order, with the attributes that make it safe.\n   *\n   * A URL the renderer refused is NOT here — it renders as plain text instead of as\n   * a live anchor that announces as a link and does nothing — so an empty answer\n   * where a link was expected is the sanitizer speaking, and {@link getText} still\n   * has the label.\n   */\n  async getLinks(): Promise<WrMarkdownHarnessLink[]> {\n    const links = await this.locatorForAll('.wr-markdown__link')();\n\n    return Promise.all(\n      links.map(async link => ({\n        text: await proseText(link),\n        href: await link.getAttribute('href'),\n        title: await link.getAttribute('title'),\n        target: await link.getAttribute('target'),\n        rel: await link.getAttribute('rel'),\n      }))\n    );\n  }\n\n  /**\n   * Every image, in document order.\n   *\n   * A refused source renders no image at all and leaves the alt text as prose,\n   * which is the information the author actually wrote — so assert this together\n   * with {@link getText} when the point is the refusal.\n   */\n  async getImages(): Promise<WrMarkdownHarnessImage[]> {\n    const images = await this.locatorForAll('.wr-markdown__image')();\n\n    return Promise.all(\n      images.map(async image => ({\n        src: await image.getAttribute('src'),\n        alt: await image.getAttribute('alt'),\n        title: await image.getAttribute('title'),\n      }))\n    );\n  }\n\n  /**\n   * The text of every inline code span, in document order.\n   *\n   * A different element from a fenced block (`<code>` on its own, not inside a\n   * `<pre>`), and never one of {@link getCodeBlocks}. Read exactly rather than\n   * collapsed, for the same reason a block is: this is code, and the spacing in it\n   * is content.\n   */\n  async getInlineCode(): Promise<string[]> {\n    const spans = await this.locatorForAll('.wr-markdown__code-inline')();\n    return Promise.all(spans.map(async span => (await span.getProperty<string | null>('textContent')) ?? ''));\n  }\n\n  /**\n   * The fenced code blocks, in document order — nested ones included.\n   *\n   * A block inside a quote or a list item is a block: it renders the same way and it\n   * gets the same copy affordance, so leaving it out would report a document as\n   * having no code because its snippet is indented under a bullet.\n   */\n  async getCodeBlocks(filters: WrMarkdownCodeBlockHarnessFilters = {}): Promise<WrMarkdownCodeBlockHarness[]> {\n    return this.locatorForAll(WrMarkdownCodeBlockHarness.with(filters))();\n  }\n\n  /**\n   * The first code block matching the filters.\n   *\n   * Throws when nothing matches, naming the languages the document does offer —\n   * a `getCodeBlocks(…)[0]` that quietly resolves to `undefined` fails several lines\n   * later, on an unrelated line, with `Cannot read properties of undefined`.\n   */\n  async getCodeBlock(filters: WrMarkdownCodeBlockHarnessFilters = {}): Promise<WrMarkdownCodeBlockHarness> {\n    const [block] = await this.getCodeBlocks(filters);\n    if (block) return block;\n\n    const languages = await Promise.all((await this.getCodeBlocks()).map(other => other.getLanguage()));\n    const offered =\n      languages.length > 0\n        ? `This document has ${languages.length} block(s), in: ${languages.map(name => name ?? '(none)').join(', ')}.`\n        : 'This document renders no code blocks at all.';\n\n    throw new Error(`WrMarkdownHarness.getCodeBlock(): no block matched ${JSON.stringify(filters)}. ${offered}`);\n  }\n\n  /**\n   * The text of every list item, in document order.\n   *\n   * Bullets, numbers and task items alike — a task item's tick state is in\n   * {@link getTaskItems} instead. NESTING is not re-derived: a nested list lives\n   * INSIDE its parent `<li>` (which is what makes the list's accessibility tree\n   * valid), so a parent's text contains its children's, and each child is also an\n   * entry of its own.\n   */\n  async getListItems(): Promise<string[]> {\n    const items = await this.locatorForAll('.wr-markdown__item')();\n    return Promise.all(items.map(item => proseText(item)));\n  }\n\n  /**\n   * Every task-list item (`- [x]` / `- [ ]`), in document order.\n   *\n   * Ordinary items are not here, so the count is the number of checkboxes in the\n   * document. Both halves of each entry are worth asserting: the `checked` flag is\n   * what a reader sees, and `stateLabel` is the only thing a screen reader gets —\n   * the tick itself is `aria-hidden`.\n   */\n  async getTaskItems(): Promise<WrMarkdownHarnessTaskItem[]> {\n    const items = await this.locatorForAll(WrMarkdownTaskItemReader)();\n    return Promise.all(items.map(item => item.read()));\n  }\n\n  /** Every table, in document order, each as a rectangle of text plus its alignment. */\n  async getTables(): Promise<WrMarkdownHarnessTable[]> {\n    const tables = await this.locatorForAll(WrMarkdownTableReader)();\n    return Promise.all(tables.map(table => table.read()));\n  }\n\n  /**\n   * The text of every blockquote, in document order.\n   *\n   * A quote holds BLOCKS, so this is everything inside it collapsed to one line —\n   * its paragraphs are also in {@link getParagraphs} and a snippet inside it is\n   * also one of {@link getCodeBlocks}.\n   */\n  async getQuotes(): Promise<string[]> {\n    const quotes = await this.locatorForAll('.wr-markdown__quote')();\n    return Promise.all(quotes.map(quote => proseText(quote)));\n  }\n\n  /**\n   * How many thematic breaks the document rendered.\n   *\n   * A count rather than a list because an `<hr>` has no content — and it is worth\n   * counting: `---` is the one construct this renderer resolves differently from\n   * some others (it is always a break here, never a setext heading underline), so a\n   * document that lost a rule gained a heading somewhere.\n   */\n  async getRuleCount(): Promise<number> {\n    return (await this.locatorForAll('.wr-markdown__rule')()).length;\n  }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":"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"}