@art-md/constructs 0.0.1 → 0.0.3

package/src/parser/constructs/NaturalBlock/private/helpers/createNaturalBlockFromNode.test.ts

@@ -0,0 +1,101 @@
+import { makeParserVisitContextMock } from '@art-md/primitives/src/test/helpers';
+import type { Node } from 'mdast';
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { describe, expect, it, vi } from 'vitest';
+
+import { createNaturalBlock } from '../../../../../factories';
+
+import { createNaturalBlockFromNode } from './createNaturalBlockFromNode';
+
+vi.mock('../../../../../factories/constructs/NaturalBlock/factory/createNaturalBlock', async () => {
+	const { createNaturalBlockMock } = await import('../../../../../test/helpers');
+	return createNaturalBlockMock();
+});
+
+describe('createNaturalBlockFromNode', () => {
+	it('WHEN creating a NaturalBlock from a paragraph', () => {
+		const markdown = 'hello';
+		const tree = fromMarkdown(markdown);
+		const node = tree.children[0] as Node;
+		const context = makeParserVisitContextMock({ markdown });
+
+		const result = createNaturalBlockFromNode(node, context);
+
+		expect(createNaturalBlock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				value: 'hello',
+				type: 'paragraph',
+				children: [
+					expect.objectContaining({
+						construct: 'NaturalExpression',
+						type: 'text',
+						value: 'hello',
+					}),
+				],
+				tags: [],
+			}),
+		);
+		expect(result).toBe(vi.mocked(createNaturalBlock).mock.results[0]?.value);
+	});
+
+	it('WHEN trailing tags follow the last text child passes them to createNaturalBlock', () => {
+		const markdown = 'hello (#test)';
+		const tree = fromMarkdown(markdown);
+		const node = tree.children[0] as Node;
+		const context = makeParserVisitContextMock({ markdown });
+
+		createNaturalBlockFromNode(node, context);
+
+		expect(createNaturalBlock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				children: [expect.objectContaining({ value: 'hello' })],
+				tags: [{ construct: 'Tag', name: 'test' }],
+			}),
+		);
+	});
+
+	it('WHEN a child is not phrasing recurses into a nested NaturalBlock', () => {
+		const markdown = '> hello';
+		const tree = fromMarkdown(markdown);
+		const node = tree.children[0] as Node;
+		const context = makeParserVisitContextMock({ markdown });
+
+		createNaturalBlockFromNode(node, context);
+
+		expect(createNaturalBlock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				type: 'blockquote',
+				children: [expect.objectContaining({ construct: 'NaturalBlock' })],
+			}),
+		);
+	});
+
+	it('FOR nodes without children creates a NaturalBlock without children', () => {
+		const markdown = '---';
+		const tree = fromMarkdown(markdown);
+		const node = tree.children[0] as Node;
+		const context = makeParserVisitContextMock({ markdown });
+
+		createNaturalBlockFromNode(node, context);
+
+		expect(createNaturalBlock).toHaveBeenCalledWith(
+			expect.objectContaining({ type: 'thematicBreak', children: [] }),
+		);
+	});
+
+	it('WHEN the node has extra mdast fields passes them as attributes', () => {
+		const markdown = '- one\n- two';
+		const tree = fromMarkdown(markdown);
+		const node = tree.children[0] as Node;
+		const context = makeParserVisitContextMock({ markdown });
+
+		createNaturalBlockFromNode(node, context);
+
+		expect(createNaturalBlock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				type: 'list',
+				attributes: expect.objectContaining({ ordered: false }),
+			}),
+		);
+	});
+});

package/src/parser/constructs/NaturalBlock/private/helpers/createNaturalBlockFromNode.ts

@@ -0,0 +1,51 @@
+import type { MdastNode, ParserVisitContext } from '@art-md/primitives';
+import { nodePosition } from '@art-md/primitives';
+import type { Node } from 'mdast';
+import { phrasing } from 'mdast-util-phrasing';
+
+import {
+	type NaturalBlock,
+	type NaturalExpression,
+	type Tag,
+	createNaturalBlock,
+} from '../../../../../factories';
+import { rawSlice } from '../../../../mdast';
+import { createNaturalExpressionFromNode } from '../../../../naturalExpression';
+import { extractTags } from '../../../../tags';
+
+export function createNaturalBlockFromNode(node: Node, context: ParserVisitContext): NaturalBlock {
+	let children: (NaturalBlock | NaturalExpression)[] = [];
+	if (Array.isArray((node as MdastNode).children)) {
+		const nodeChildren = (node as MdastNode).children ?? [];
+		const phrasingContainer =
+			node.type === 'paragraph' || node.type === 'heading' || node.type === 'tableCell';
+		children = nodeChildren.map(child =>
+			phrasingContainer || phrasing(child)
+				? createNaturalExpressionFromNode(child)
+				: createNaturalBlockFromNode(child as Node, context),
+		);
+	}
+
+	let tags: Tag[] = [];
+	if (node.type === 'paragraph') {
+		const last = children[children.length - 1];
+		if (last?.type === 'text' && typeof last.value === 'string') {
+			const { tags: extractedTags, stripped } = extractTags(last.value);
+			if (extractedTags.length) {
+				tags = extractedTags;
+				last.value = stripped;
+			}
+		}
+	}
+
+	const { type, ...attributes } = node as MdastNode;
+	const block = createNaturalBlock({
+		value: rawSlice(node, context),
+		children,
+		type,
+		attributes,
+		tags,
+	});
+	block.position = nodePosition(node);
+	return block;
+}

package/src/parser/constructs/NaturalBlock/private/index.ts

@@ -0,0 +1 @@
+export * from './processor/createNaturalBlockProcessor';

package/src/parser/constructs/NaturalBlock/private/processor/createNaturalBlockProcessor.test.ts

@@ -0,0 +1,24 @@
+import { makeParserVisitContextMock } from '@art-md/primitives/src/test/helpers';
+import { describe, expect, it, vi } from 'vitest';
+
+import { createNaturalBlockFromNodeMock } from '../../../../../test/helpers';
+import { createNaturalBlockFromNode } from '../helpers/createNaturalBlockFromNode';
+
+import { createNaturalBlockProcessor } from './createNaturalBlockProcessor';
+
+vi.mock('../helpers/createNaturalBlockFromNode', async () => {
+	return createNaturalBlockFromNodeMock();
+});
+
+describe('createNaturalBlockProcessor', () => {
+	it('WHEN capturing a node returns the createNaturalBlockFromNode result', () => {
+		const processor = createNaturalBlockProcessor();
+		const context = makeParserVisitContextMock();
+		const node = { type: 'paragraph', children: [] };
+
+		const result = processor.captureNode(context, node);
+
+		expect(createNaturalBlockFromNode).toHaveBeenCalledWith(node, context);
+		expect(result).toBe(vi.mocked(createNaturalBlockFromNode).mock.results[0]?.value);
+	});
+});

package/src/parser/constructs/NaturalBlock/private/processor/createNaturalBlockProcessor.ts

@@ -0,0 +1,10 @@
+import type { ConstructProcessor } from '../../../../types';
+import { createNaturalBlockFromNode } from '../helpers/createNaturalBlockFromNode';
+
+export function createNaturalBlockProcessor(): ConstructProcessor {
+	return {
+		captureNode(context, node) {
+			return createNaturalBlockFromNode(node, context);
+		},
+	};
+}

package/src/parser/constructs/SectionBlock/createSectionBlockParser.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+
+import { createSectionBlockParser } from './createSectionBlockParser';
+
+describe('createSectionBlockParser', () => {
+	it('WHEN called returns a parser with SectionBlock name, processor, integrator and factory', () => {
+		const parser = createSectionBlockParser();
+
+		expect(parser.name).toBe('SectionBlock');
+		expect(parser.processor).toBeDefined();
+		expect(parser.integrator).toBeDefined();
+	});
+});

package/src/parser/constructs/SectionBlock/createSectionBlockParser.ts

@@ -0,0 +1,9 @@
+import type { ConstructParserFactory } from '../../types';
+
+import { createSectionBlockIntegrator, createSectionBlockProcessor } from './private';
+
+export const createSectionBlockParser: ConstructParserFactory = () => ({
+	name: 'SectionBlock',
+	processor: createSectionBlockProcessor(),
+	integrator: createSectionBlockIntegrator(),
+});

package/src/parser/constructs/SectionBlock/index.ts

@@ -0,0 +1 @@
+export { createSectionBlockParser } from './createSectionBlockParser';

package/src/parser/constructs/SectionBlock/private/constants.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+
+import { KIND_PATTERN } from './constants';
+
+describe('KIND_PATTERN', () => {
+	it('WHEN matching a kind pattern', () => {
+		const result = 'Module: Hello'.match(KIND_PATTERN);
+
+		expect(result).toBeTruthy();
+		expect(result?.[1]).toBe('Module');
+		expect(result?.[2]).toBe('Hello');
+	});
+
+	it('WHEN match text without colon does not', () => {
+		expect('Hello World'.match(KIND_PATTERN)).toBeFalsy();
+	});
+});

package/src/parser/constructs/SectionBlock/private/constants.ts

@@ -0,0 +1 @@
+export const KIND_PATTERN = /^([\w-]+(?: [\w-]+)*):\s*(.+)$/;

package/src/parser/constructs/SectionBlock/private/helpers/createSectionBlockFromNode.test.ts

@@ -0,0 +1,58 @@
+import { makeParserVisitContextMock } from '@art-md/primitives/src/test/helpers';
+import type { Heading } from 'mdast';
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { describe, expect, it, vi } from 'vitest';
+
+import { createSectionBlock } from '../../../../../factories';
+
+import { createSectionBlockFromNode } from './createSectionBlockFromNode';
+
+vi.mock('../../../../../factories/constructs/SectionBlock/factory/createSectionBlock', async () => {
+	const { createSectionBlockMock } = await import('../../../../../test/helpers');
+	return createSectionBlockMock();
+});
+
+describe('createSectionBlockFromNode', () => {
+	it('WHEN creating a SectionBlock from a heading', () => {
+		const markdown = '# Hello World';
+		const tree = fromMarkdown(markdown);
+		const heading = tree.children[0] as Heading;
+		const context = makeParserVisitContextMock({ markdown });
+
+		const result = createSectionBlockFromNode(heading, context);
+
+		expect(createSectionBlock).toHaveBeenCalledWith(
+			expect.objectContaining({ name: 'Hello World', depth: 1, children: [], tags: [] }),
+		);
+		expect(result).toBe(vi.mocked(createSectionBlock).mock.results[0]?.value);
+	});
+
+	it('WHEN the heading declares a kind extracts it', () => {
+		const markdown = '# Module: Hello';
+		const tree = fromMarkdown(markdown);
+		const heading = tree.children[0] as Heading;
+		const context = makeParserVisitContextMock({ markdown });
+
+		createSectionBlockFromNode(heading, context);
+
+		expect(createSectionBlock).toHaveBeenCalledWith(
+			expect.objectContaining({ kind: 'Module', name: 'Hello' }),
+		);
+	});
+
+	it('WHEN the heading has trailing tags passes them and strips the name', () => {
+		const markdown = '# Hello (#tag)';
+		const tree = fromMarkdown(markdown);
+		const heading = tree.children[0] as Heading;
+		const context = makeParserVisitContextMock({ markdown });
+
+		createSectionBlockFromNode(heading, context);
+
+		expect(createSectionBlock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				name: 'Hello',
+				tags: [{ construct: 'Tag', name: 'tag' }],
+			}),
+		);
+	});
+});

package/src/parser/constructs/SectionBlock/private/helpers/createSectionBlockFromNode.ts

@@ -0,0 +1,28 @@
+import { nodePosition } from '@art-md/primitives';
+import type { ParserVisitContext } from '@art-md/primitives';
+import type { Heading } from 'mdast';
+
+import { type SectionBlock, createSectionBlock } from '../../../../../factories';
+import { rawSlice } from '../../../../mdast';
+import { extractTags } from '../../../../tags';
+import { KIND_PATTERN } from '../constants';
+
+export function createSectionBlockFromNode(
+	node: Heading,
+	context: ParserVisitContext,
+): SectionBlock {
+	const text = rawSlice(node, context)
+		.replace(/^[ \t]*#+[ \t]*/, '')
+		.trim();
+	const { tags, stripped } = extractTags(text);
+	const kindMatch = stripped.match(KIND_PATTERN);
+	const section = createSectionBlock({
+		name: kindMatch?.[2]?.trim() ?? stripped,
+		kind: kindMatch?.[1],
+		depth: node.depth,
+		children: [],
+		tags,
+	});
+	section.position = nodePosition(node);
+	return section;
+}

package/src/parser/constructs/SectionBlock/private/helpers/findParentSection.test.ts

@@ -0,0 +1,44 @@
+import type { ParserVisitContext } from '@art-md/primitives';
+import { makeDocumentMock, makeParserVisitContextMock } from '@art-md/primitives/src/test/helpers';
+import { describe, expect, it } from 'vitest';
+
+import { makeFieldBlockFixture, makeSectionBlockFixture } from '../../../../../test/helpers';
+
+import { findParentSection } from './findParentSection';
+
+function makeContext(construct: ParserVisitContext['construct'], parent?: ParserVisitContext) {
+	return {
+		...makeParserVisitContextMock(),
+		construct,
+		parent: () => parent,
+	};
+}
+
+describe('findParentSection', () => {
+	it('WHEN found in context chain returns the section block', () => {
+		const section = makeSectionBlockFixture();
+		const context = makeContext(section);
+
+		const result = findParentSection(context);
+
+		expect(result).toBe(section);
+	});
+
+	it('WHEN no section block is found returns undefined', () => {
+		const context = makeContext(makeDocumentMock());
+
+		const result = findParentSection(context);
+
+		expect(result).toBeUndefined();
+	});
+
+	it('WHEN walking up the parent chain', () => {
+		const section = makeSectionBlockFixture();
+		const parent = makeContext(section);
+		const context = makeContext(makeFieldBlockFixture(), parent);
+
+		const result = findParentSection(context);
+
+		expect(result).toBe(section);
+	});
+});

package/src/parser/constructs/SectionBlock/private/helpers/findParentSection.ts

@@ -0,0 +1,14 @@
+import type { ParserVisitContext } from '@art-md/primitives';
+
+import type { SectionBlock } from '../../../../../factories';
+
+export function findParentSection(context: ParserVisitContext): SectionBlock | undefined {
+	let current: ParserVisitContext | undefined = context;
+	while (current) {
+		if (current.construct?.construct === 'SectionBlock') {
+			return current.construct as SectionBlock;
+		}
+		current = current.parent();
+	}
+	return undefined;
+}

package/src/parser/constructs/SectionBlock/private/index.ts

@@ -0,0 +1,2 @@
+export * from './integrator/createSectionBlockIntegrator';
+export * from './processor/createSectionBlockProcessor';

package/src/parser/constructs/SectionBlock/private/integrator/createSectionBlockIntegrator.test.ts

@@ -0,0 +1,60 @@
+import { createParserVisitContext } from '@art-md/primitives';
+import { makeDocumentMock, makeParserVisitContextMock } from '@art-md/primitives/src/test/helpers';
+import type { Heading } from 'mdast';
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { describe, expect, it, vi } from 'vitest';
+
+import { makeSectionBlockFixture } from '../../../../../test/helpers';
+
+import { createSectionBlockIntegrator } from './createSectionBlockIntegrator';
+
+function makeHeading(markdown: string): Heading {
+	return fromMarkdown(markdown).children[0] as Heading;
+}
+
+describe('createSectionBlockIntegrator', () => {
+	it('WHEN integrating captures the construct and returns a child context', () => {
+		const integrator = createSectionBlockIntegrator();
+		const context = makeParserVisitContextMock();
+		const nextContext = makeParserVisitContextMock();
+		vi.mocked(context.childContext).mockReturnValue(nextContext);
+		const section = makeSectionBlockFixture();
+
+		const result = integrator.integrate(context, makeHeading('# Hello'), section);
+
+		expect(context.captureChildConstruct).toHaveBeenCalledWith(section);
+		expect(context.childContext).toHaveBeenCalledWith(section);
+		expect(result).toBe(nextContext);
+	});
+
+	it('WHEN the nearest section is at or below the heading depth pops to its parent', () => {
+		const integrator = createSectionBlockIntegrator();
+		const documentContext = createParserVisitContext(makeDocumentMock(), {
+			markdown: '',
+			tree: fromMarkdown(''),
+		});
+		const capture = vi.spyOn(documentContext, 'captureChildConstruct');
+		const sectionContext = documentContext.childContext(makeSectionBlockFixture({ depth: 2 }));
+		const context = sectionContext.childContext(makeSectionBlockFixture({ depth: 2 }));
+		const section = makeSectionBlockFixture();
+
+		integrator.integrate(context, makeHeading('# Hello'), section);
+
+		expect(capture).toHaveBeenCalledWith(section);
+	});
+
+	it('WHEN the nearest section is above the heading depth stops at it', () => {
+		const integrator = createSectionBlockIntegrator();
+		const documentContext = createParserVisitContext(makeDocumentMock(), {
+			markdown: '',
+			tree: fromMarkdown(''),
+		});
+		const context = documentContext.childContext(makeSectionBlockFixture({ depth: 1 }));
+		const capture = vi.spyOn(context, 'captureChildConstruct');
+		const section = makeSectionBlockFixture();
+
+		integrator.integrate(context, makeHeading('## Hello'), section);
+
+		expect(capture).toHaveBeenCalledWith(section);
+	});
+});

package/src/parser/constructs/SectionBlock/private/integrator/createSectionBlockIntegrator.ts

@@ -0,0 +1,31 @@
+import { sectionDepth } from '@art-md/primitives';
+import type { Heading } from 'mdast';
+
+import type { SectionBlock } from '../../../../../factories';
+import type { ConstructIntegrator } from '../../../../types';
+import { findParentSection } from '../helpers/findParentSection';
+
+export function createSectionBlockIntegrator(): ConstructIntegrator {
+	return {
+		integrate(context, node, construct) {
+			const section = construct as SectionBlock;
+			let currentContext = context;
+
+			const heading = node as Heading;
+			while (currentContext.construct.construct === 'SectionBlock') {
+				const parentSection = findParentSection(currentContext);
+				if (parentSection && sectionDepth(parentSection) >= heading.depth) {
+					const parentContext = currentContext.parent();
+					if (parentContext) {
+						currentContext = parentContext;
+					}
+				} else {
+					break;
+				}
+			}
+
+			currentContext.captureChildConstruct(section);
+			return currentContext.childContext(section);
+		},
+	};
+}

package/src/parser/constructs/SectionBlock/private/processor/createSectionBlockProcessor.test.ts

@@ -0,0 +1,34 @@
+import { makeParserVisitContextMock } from '@art-md/primitives/src/test/helpers';
+import { describe, expect, it, vi } from 'vitest';
+
+import { createSectionBlockFromNodeMock } from '../../../../../test/helpers';
+import { createSectionBlockFromNode } from '../helpers/createSectionBlockFromNode';
+
+import { createSectionBlockProcessor } from './createSectionBlockProcessor';
+
+vi.mock('../helpers/createSectionBlockFromNode', async () => {
+	return createSectionBlockFromNodeMock();
+});
+
+describe('createSectionBlockProcessor', () => {
+	it('FOR non-heading nodes returns null', () => {
+		const processor = createSectionBlockProcessor();
+		const context = makeParserVisitContextMock();
+		const node = { type: 'paragraph', children: [] };
+
+		const result = processor.captureNode(context, node);
+
+		expect(result).toBeNull();
+	});
+
+	it('WHEN capturing a heading returns the createSectionBlockFromNode result', () => {
+		const processor = createSectionBlockProcessor();
+		const context = makeParserVisitContextMock();
+		const node = { type: 'heading', children: [] };
+
+		const result = processor.captureNode(context, node);
+
+		expect(createSectionBlockFromNode).toHaveBeenCalledWith(node, context);
+		expect(result).toBe(vi.mocked(createSectionBlockFromNode).mock.results[0]?.value);
+	});
+});

package/src/parser/constructs/SectionBlock/private/processor/createSectionBlockProcessor.ts

@@ -0,0 +1,15 @@
+import type { Heading } from 'mdast';
+
+import type { ConstructProcessor } from '../../../../types';
+import { createSectionBlockFromNode } from '../helpers/createSectionBlockFromNode';
+
+export function createSectionBlockProcessor(): ConstructProcessor {
+	return {
+		captureNode(context, node) {
+			if (node.type !== 'heading') {
+				return null;
+			}
+			return createSectionBlockFromNode(node as Heading, context);
+		},
+	};
+}

package/src/parser/document/createArtDocumentFromNode.test.ts

@@ -0,0 +1,23 @@
+import { nodePositionMock } from '@art-md/primitives/src/test/helpers';
+import { describe, expect, it, vi } from 'vitest';
+
+import { createArtDocumentFromNode } from './createArtDocumentFromNode';
+
+vi.mock('@art-md/primitives', async () => {
+	const actual = await import('@art-md/primitives');
+	return {
+		...actual,
+		...nodePositionMock(),
+	};
+});
+
+describe('createArtDocument', () => {
+	it('WHEN creating an ArtDocument from a root node', async () => {
+		const root = { type: 'root' };
+
+		const result = createArtDocumentFromNode(root);
+
+		expect(result.construct).toBe('Document');
+		expect(result.children).toEqual([]);
+	});
+});

package/src/parser/document/createArtDocumentFromNode.ts

@@ -0,0 +1,10 @@
+import { type ArtDocument, nodePosition } from '@art-md/primitives';
+import type { Node } from 'unist';
+
+import { createDocument } from '../../factories';
+
+export function createArtDocumentFromNode(root: Node): ArtDocument {
+	const document = createDocument({});
+	document.position = nodePosition(root);
+	return document;
+}

package/src/parser/document/index.ts

@@ -0,0 +1 @@
+export * from './createArtDocumentFromNode';

package/src/parser/fields/constants.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+
+import { FIELD_TEXT_PATTERN } from './constants';
+
+describe('FIELD_TEXT_PATTERN', () => {
+	it('WHEN matching a field text pattern', () => {
+		const resultPurpose = 'Purpose: '.match(FIELD_TEXT_PATTERN);
+
+		const resultMyField = 'My Field: '.match(FIELD_TEXT_PATTERN);
+
+		expect(resultPurpose).toBeTruthy();
+		expect(resultMyField).toBeTruthy();
+	});
+
+	it('WHEN match non-field text does not', () => {
+		const resultHello = 'hello'.match(FIELD_TEXT_PATTERN);
+
+		const resultNoColon = 'no colon'.match(FIELD_TEXT_PATTERN);
+
+		expect(resultHello).toBeFalsy();
+		expect(resultNoColon).toBeFalsy();
+	});
+});

package/src/parser/fields/constants.ts

@@ -0,0 +1 @@
+export const FIELD_TEXT_PATTERN = /^[A-Za-z][A-Za-z ]*:(?:\s|$)/;

package/src/parser/fields/index.ts

@@ -0,0 +1,3 @@
+export { FIELD_TEXT_PATTERN } from './constants';
+export { isFieldStrong } from './isFieldStrong';
+export { stripStrong } from './stripStrong';

package/src/parser/fields/isFieldStrong.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { stripStrongMock } from '../../test/helpers';
+
+import { isFieldStrong } from './isFieldStrong';
+
+vi.mock('./stripStrong', () => {
+	return stripStrongMock('Purpose:');
+});
+
+describe('isFieldStrong', () => {
+	it('FOR a strong node matching field pattern returns true', () => {
+		const node = { type: 'strong', children: [{ type: 'text', value: 'Purpose:' }] };
+
+		const result = isFieldStrong(node, { markdown: '**Purpose:**' } as never);
+
+		expect(result).toBe(true);
+	});
+
+	it('FOR non-strong node returns false', () => {
+		const node = { type: 'text', value: 'Purpose:' };
+
+		const result = isFieldStrong(node, { markdown: 'Purpose:' } as never);
+
+		expect(result).toBe(false);
+	});
+});

package/src/parser/fields/isFieldStrong.ts

@@ -0,0 +1,9 @@
+import type { ParserVisitContext } from '@art-md/primitives';
+import type { Node, Strong } from 'mdast';
+
+import { FIELD_TEXT_PATTERN } from './constants';
+import { stripStrong } from './stripStrong';
+
+export function isFieldStrong(node: Node, context: ParserVisitContext): node is Strong {
+	return node.type === 'strong' && FIELD_TEXT_PATTERN.test(stripStrong(node as Strong, context));
+}