@art-md/constructs 0.0.1 → 0.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@art-md/constructs",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Construct factories for Art parser records.",
   "author": "Noodlestan Collective",
   "license": "MIT",
@@ -17,7 +17,7 @@
   "sideEffects": false,
   "main": "./src/index.ts",
   "files": [
-    "dist",
+    "src",
     "LICENSE-MIT",
     "README.md"
   ],

package/src/factories/constructs/Document/factory/createDocument.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+
+import type { SectionBlock } from '../../SectionBlock';
+
+import { createDocument } from './createDocument';
+
+describe('createDocument', () => {
+	it('WHEN creating an ArtDocument from data', () => {
+		const sectionBlock: SectionBlock = { construct: 'SectionBlock', name: 'Hello', children: [] };
+		const data = { children: [sectionBlock] };
+
+		const result = createDocument(data);
+
+		expect(result.construct).toBe('Document');
+		expect(result.children).toBe(data.children);
+	});
+});

package/src/factories/constructs/Document/factory/createDocument.ts

@@ -0,0 +1,11 @@
+import { type ArtDocument, createArtDocument } from '@art-md/primitives';
+
+import type { DocumentFactoryData } from './types';
+
+export function createDocument(data: DocumentFactoryData): ArtDocument {
+	const docData = {
+		...data,
+		children: data.children || [],
+	};
+	return createArtDocument(docData);
+}

package/src/factories/constructs/Document/factory/types.ts

@@ -0,0 +1,5 @@
+import type { BlockContent } from '../../../types';
+
+export type DocumentFactoryData = {
+	children?: BlockContent[];
+};

package/src/factories/constructs/Document/index.ts

@@ -0,0 +1,3 @@
+export { createDocument } from './factory/createDocument';
+
+export type { DocumentFactoryData } from './factory/types';

package/src/factories/constructs/FieldBlock/factory/createFieldBlock.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+	makeFieldBlockFixture,
+	makeNaturalBlockFixture,
+	makeTagFixture,
+} from '../../../../test/helpers';
+
+import { createFieldBlock } from './createFieldBlock';
+
+describe('createFieldBlock', () => {
+	it('WHEN creating a FieldBlock from minimal data', () => {
+		const result = createFieldBlock({ name: 'Test' });
+		expect(result).toEqual(makeFieldBlockFixture());
+	});
+
+	it('WHEN provided includes children and tags', () => {
+		const result = createFieldBlock({
+			name: 'Test',
+			children: [makeNaturalBlockFixture()],
+			tags: [makeTagFixture()],
+		});
+		expect(result.children).toHaveLength(1);
+		expect(result.tags).toHaveLength(1);
+	});
+});

package/src/factories/constructs/FieldBlock/factory/createFieldBlock.ts

@@ -0,0 +1,15 @@
+import type { FieldBlock } from '../types';
+
+import type { FieldBlockFactoryData } from './types';
+
+export function createFieldBlock(data: FieldBlockFactoryData): FieldBlock {
+	const field: FieldBlock = {
+		construct: 'FieldBlock',
+		name: data.name,
+		children: data.children ?? [],
+	};
+	if (data.tags?.length) {
+		field.tags = data.tags;
+	}
+	return field;
+}

package/src/factories/constructs/FieldBlock/factory/types.ts

@@ -0,0 +1,8 @@
+import type { BlockContent } from '../../../types';
+import type { Tag } from '../../Tag';
+
+export type FieldBlockFactoryData = {
+	name: string;
+	children?: BlockContent[];
+	tags?: Tag[];
+};

package/src/factories/constructs/FieldBlock/index.ts

@@ -0,0 +1,4 @@
+export { createFieldBlock } from './factory/createFieldBlock';
+
+export type { FieldBlock } from './types';
+export type { FieldBlockFactoryData } from './factory/types';

package/src/factories/constructs/FieldBlock/types.ts

@@ -0,0 +1,11 @@
+import type { ContainerConstructBase } from '@art-md/primitives';
+
+import type { BlockContent } from '../../types';
+import type { Tag } from '../Tag';
+
+export type FieldBlock = ContainerConstructBase & {
+	construct: 'FieldBlock';
+	name: string;
+	children: BlockContent[];
+	tags?: Tag[];
+};

package/src/factories/constructs/FieldInline/factory/createFieldInline.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+	makeFieldInlineFixture,
+	makeNaturalExpressionFixture,
+	makeTagFixture,
+} from '../../../../test/helpers';
+
+import { createFieldInline } from './createFieldInline';
+
+describe('createFieldInline', () => {
+	it('WHEN creating a FieldInline from minimal data', () => {
+		const result = createFieldInline({ name: 'Test' });
+		expect(result).toEqual(makeFieldInlineFixture());
+	});
+
+	it('WHEN provided includes children and tags', () => {
+		const result = createFieldInline({
+			name: 'Test',
+			children: [makeNaturalExpressionFixture()],
+			tags: [makeTagFixture()],
+		});
+		expect(result.children).toHaveLength(1);
+		expect(result.tags).toHaveLength(1);
+	});
+});

package/src/factories/constructs/FieldInline/factory/createFieldInline.ts

@@ -0,0 +1,15 @@
+import type { FieldInline } from '../types';
+
+import type { FieldInlineFactoryData } from './types';
+
+export function createFieldInline(data: FieldInlineFactoryData): FieldInline {
+	const field: FieldInline = {
+		construct: 'FieldInline',
+		name: data.name,
+		children: data.children ?? [],
+	};
+	if (data.tags?.length) {
+		field.tags = data.tags;
+	}
+	return field;
+}

package/src/factories/constructs/FieldInline/factory/types.ts

@@ -0,0 +1,8 @@
+import type { NaturalExpression } from '../../NaturalExpression';
+import type { Tag } from '../../Tag';
+
+export type FieldInlineFactoryData = {
+	name: string;
+	children?: NaturalExpression[];
+	tags?: Tag[];
+};

package/src/factories/constructs/FieldInline/index.ts

@@ -0,0 +1,4 @@
+export { createFieldInline } from './factory/createFieldInline';
+
+export type { FieldInline } from './types';
+export type { FieldInlineFactoryData } from './factory/types';

package/src/factories/constructs/FieldInline/types.ts

@@ -0,0 +1,11 @@
+import type { ContainerConstructBase } from '@art-md/primitives';
+
+import type { NaturalExpression } from '../NaturalExpression';
+import type { Tag } from '../Tag';
+
+export type FieldInline = ContainerConstructBase & {
+	construct: 'FieldInline';
+	name: string;
+	children: NaturalExpression[];
+	tags?: Tag[];
+};

package/src/factories/constructs/NaturalBlock/factory/createNaturalBlock.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+
+import { makeNaturalBlockFixture, makeTagFixture } from '../../../../test/helpers';
+
+import { createNaturalBlock } from './createNaturalBlock';
+
+describe('createNaturalBlock', () => {
+	it('WHEN creating a NaturalBlock from minimal data', () => {
+		const result = createNaturalBlock({ value: 'hello', children: [] });
+		expect(result).toEqual(makeNaturalBlockFixture());
+	});
+
+	it('WHEN provided includes optional properties', () => {
+		const result = createNaturalBlock({
+			value: 'hello',
+			children: [],
+			type: 'paragraph',
+			lang: 'ts',
+			meta: 'test',
+			tags: [makeTagFixture()],
+		});
+		expect(result.type).toBe('paragraph');
+		expect(result.lang).toBe('ts');
+		expect(result.meta).toBe('test');
+		expect(result.tags).toHaveLength(1);
+	});
+
+	it('WHEN provided includes attributes spreads them without overriding value and children', () => {
+		const result = createNaturalBlock({
+			value: 'hello',
+			children: [],
+			attributes: { ordered: true, value: 'nope', children: ['x'] },
+		});
+		expect(result).toMatchObject({ ordered: true, value: 'hello', children: [] });
+	});
+});

package/src/factories/constructs/NaturalBlock/factory/createNaturalBlock.ts

@@ -0,0 +1,25 @@
+import type { NaturalBlock } from '../types';
+
+import type { NaturalBlockFactoryData } from './types';
+
+export function createNaturalBlock(data: NaturalBlockFactoryData): NaturalBlock {
+	const block: NaturalBlock = {
+		...data.attributes,
+		construct: 'NaturalBlock',
+		value: data.value,
+		children: data.children,
+	};
+	if (data.type) {
+		block.type = data.type;
+	}
+	if (data.lang !== undefined) {
+		block.lang = data.lang;
+	}
+	if (data.meta !== undefined) {
+		block.meta = data.meta;
+	}
+	if (data.tags?.length) {
+		block.tags = data.tags;
+	}
+	return block;
+}

package/src/factories/constructs/NaturalBlock/factory/types.ts

@@ -0,0 +1,13 @@
+import type { ContainerConstructBase } from '@art-md/primitives';
+
+import type { Tag } from '../../Tag';
+
+export type NaturalBlockFactoryData = {
+	value: string;
+	children: ContainerConstructBase[];
+	type?: string;
+	lang?: string | null;
+	meta?: string | null;
+	tags?: Tag[];
+	attributes?: Record<string, unknown>;
+};

package/src/factories/constructs/NaturalBlock/index.ts

@@ -0,0 +1,4 @@
+export { createNaturalBlock } from './factory/createNaturalBlock';
+
+export type { NaturalBlock } from './types';
+export type { NaturalBlockFactoryData } from './factory/types';

package/src/factories/constructs/NaturalBlock/types.ts

@@ -0,0 +1,14 @@
+import type { ContainerConstructBase } from '@art-md/primitives';
+
+import type { Tag } from '../Tag';
+
+export type NaturalBlock = ContainerConstructBase & {
+	construct: 'NaturalBlock';
+	value: string;
+	children: ContainerConstructBase[];
+	type?: string;
+	lang?: string | null;
+	meta?: string | null;
+	tags?: Tag[];
+	[key: string]: unknown;
+};

package/src/factories/constructs/NaturalExpression/factory/createNaturalExpression.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+
+import { makeNaturalExpressionFixture } from '../../../../test/helpers';
+
+import { createNaturalExpression } from './createNaturalExpression';
+
+describe('createNaturalExpression', () => {
+	it('WHEN creating a NaturalExpression from data', () => {
+		const result = createNaturalExpression({ type: 'text', value: 'hello' });
+		expect(result).toEqual(makeNaturalExpressionFixture());
+	});
+
+	it('WHEN provided includes children and attributes', () => {
+		const result = createNaturalExpression({
+			type: 'strong',
+			attributes: { bold: true },
+			children: [makeNaturalExpressionFixture({ value: 'hi' })],
+		});
+		expect(result.attributes).toEqual({ bold: true });
+		expect(result.children).toHaveLength(1);
+	});
+});

package/src/factories/constructs/NaturalExpression/factory/createNaturalExpression.ts

@@ -0,0 +1,13 @@
+import type { NaturalExpression } from '../types';
+
+import type { NaturalExpressionFactoryData } from './types';
+
+export function createNaturalExpression(data: NaturalExpressionFactoryData): NaturalExpression {
+	return {
+		construct: 'NaturalExpression',
+		type: data.type,
+		value: data.value,
+		attributes: data.attributes,
+		children: data.children ?? [],
+	};
+}

package/src/factories/constructs/NaturalExpression/factory/types.ts

@@ -0,0 +1,8 @@
+import type { NaturalExpression } from '../types';
+
+export type NaturalExpressionFactoryData = {
+	type: string;
+	value?: string;
+	attributes?: Record<string, unknown>;
+	children?: NaturalExpression[];
+};

package/src/factories/constructs/NaturalExpression/index.ts

@@ -0,0 +1,4 @@
+export { createNaturalExpression } from './factory/createNaturalExpression';
+
+export type { NaturalExpression } from './types';
+export type { NaturalExpressionFactoryData } from './factory/types';

package/src/factories/constructs/NaturalExpression/types.ts

@@ -0,0 +1,9 @@
+import type { ContainerConstructBase } from '@art-md/primitives';
+
+export type NaturalExpression = ContainerConstructBase & {
+	construct: 'NaturalExpression';
+	type: string;
+	attributes?: Record<string, unknown>;
+	value?: string;
+	children: NaturalExpression[];
+};

package/src/factories/constructs/SectionBlock/factory/createSectionBlock.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+	makeNaturalBlockFixture,
+	makeSectionBlockFixture,
+	makeTagFixture,
+} from '../../../../test/helpers';
+
+import { createSectionBlock } from './createSectionBlock';
+
+describe('createSectionBlock', () => {
+	it('WHEN creating a SectionBlock from minimal data', () => {
+		const result = createSectionBlock({ name: 'Test' });
+		expect(result).toEqual(makeSectionBlockFixture());
+	});
+
+	it('WHEN provided includes optional properties', () => {
+		const result = createSectionBlock({
+			name: 'Test',
+			kind: 'Module',
+			depth: 2,
+			children: [makeNaturalBlockFixture()],
+			tags: [makeTagFixture()],
+		});
+		expect(result.kind).toBe('Module');
+		expect(result.depth).toBe(2);
+		expect(result.children).toHaveLength(1);
+		expect(result.tags).toHaveLength(1);
+	});
+});

package/src/factories/constructs/SectionBlock/factory/createSectionBlock.ts

@@ -0,0 +1,15 @@
+import type { SectionBlock } from '../types';
+
+import type { SectionBlockFactoryData } from './types';
+
+export function createSectionBlock(data: SectionBlockFactoryData): SectionBlock {
+	const section: SectionBlock = {
+		construct: 'SectionBlock',
+		name: data.name,
+		children: data.children ?? [],
+	};
+	if (data.kind) section.kind = data.kind;
+	if (data.depth !== undefined) section.depth = data.depth;
+	if (data.tags?.length) section.tags = data.tags;
+	return section;
+}

package/src/factories/constructs/SectionBlock/factory/types.ts

@@ -0,0 +1,11 @@
+import type { ConstructBase } from '@art-md/primitives';
+
+import type { Tag } from '../../Tag';
+
+export type SectionBlockFactoryData = {
+	name: string;
+	kind?: string;
+	depth?: number;
+	children?: ConstructBase[];
+	tags?: Tag[];
+};

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

@@ -0,0 +1,4 @@
+export { createSectionBlock } from './factory/createSectionBlock';
+
+export type { SectionBlock } from './types';
+export type { SectionBlockFactoryData } from './factory/types';

package/src/factories/constructs/SectionBlock/types.ts

@@ -0,0 +1,12 @@
+import type { ConstructBase, ContainerConstructBase } from '@art-md/primitives';
+
+import type { Tag } from '../Tag';
+
+export type SectionBlock = ContainerConstructBase & {
+	construct: 'SectionBlock';
+	kind?: string;
+	name: string;
+	tags?: Tag[];
+	children: ConstructBase[];
+	depth?: number;
+};

package/src/factories/constructs/Tag/factory/createTag.test.ts

@@ -0,0 +1,10 @@
+import { describe, expect, it } from 'vitest';
+
+import { createTag } from './createTag';
+
+describe('createTag', () => {
+	it('WHEN creating a Tag from data', () => {
+		const result = createTag({ name: 'friend' });
+		expect(result).toEqual({ construct: 'Tag', name: 'friend' });
+	});
+});

package/src/factories/constructs/Tag/factory/createTag.ts

@@ -0,0 +1,7 @@
+import type { Tag } from '../types';
+
+import type { TagFactoryData } from './types';
+
+export function createTag(tagData: TagFactoryData): Tag {
+	return { construct: 'Tag' as const, name: tagData.name };
+}

package/src/factories/constructs/Tag/factory/types.ts

@@ -0,0 +1,3 @@
+export type TagFactoryData = {
+	name: string;
+};

package/src/factories/constructs/Tag/index.ts

@@ -0,0 +1,4 @@
+export { createTag } from './factory/createTag';
+
+export type { Tag } from './types';
+export type { TagFactoryData } from './factory/types';

package/src/factories/constructs/Tag/types.ts

@@ -0,0 +1,6 @@
+import type { ConstructBase } from '@art-md/primitives';
+
+export type Tag = ConstructBase & {
+	construct: 'Tag';
+	name: string;
+};

package/src/factories/index.ts

@@ -0,0 +1,9 @@
+export * from './constructs/Document';
+export * from './constructs/FieldBlock';
+export * from './constructs/FieldInline';
+export * from './constructs/NaturalBlock';
+export * from './constructs/NaturalExpression';
+export * from './constructs/SectionBlock';
+export * from './constructs/Tag';
+
+export type * from './types';

package/src/factories/public.ts

@@ -0,0 +1,47 @@
+import { createDocument } from './constructs/Document';
+import { createFieldBlock } from './constructs/FieldBlock';
+import { createFieldInline } from './constructs/FieldInline';
+import { createNaturalBlock } from './constructs/NaturalBlock';
+import { createNaturalExpression } from './constructs/NaturalExpression';
+import { createSectionBlock } from './constructs/SectionBlock';
+import { createTag } from './constructs/Tag';
+
+export type { FieldBlock } from './constructs/FieldBlock';
+export type { FieldInline } from './constructs/FieldInline';
+export type { NaturalBlock } from './constructs/NaturalBlock';
+export type { NaturalExpression } from './constructs/NaturalExpression';
+export type { SectionBlock } from './constructs/SectionBlock';
+export type { Tag } from './constructs/Tag';
+
+export type * from './types';
+
+export const FACTORIES = [
+	{
+		name: 'Document',
+		factory: createDocument,
+	},
+	{
+		name: 'FieldBlock',
+		factory: createFieldBlock,
+	},
+	{
+		name: 'FieldInline',
+		factory: createFieldInline,
+	},
+	{
+		name: 'NaturalBlock',
+		factory: createNaturalBlock,
+	},
+	{
+		name: 'NaturalExpression',
+		factory: createNaturalExpression,
+	},
+	{
+		name: 'SectionBlock',
+		factory: createSectionBlock,
+	},
+	{
+		name: 'Tag',
+		factory: createTag,
+	},
+];

package/src/factories/types.ts

@@ -0,0 +1,36 @@
+import type { FieldBlock } from './constructs/FieldBlock';
+import type { FieldInline } from './constructs/FieldInline';
+import type { NaturalBlock } from './constructs/NaturalBlock';
+import type { NaturalExpression } from './constructs/NaturalExpression';
+import type { SectionBlock } from './constructs/SectionBlock';
+import type { Tag } from './constructs/Tag';
+
+/**
+ * Open registry of block-level constructs. Augment via declaration merging when new constructs land.
+ *
+ * @conventions-ignore Conventions: Typescript / Types / No Interface
+ */
+export interface BlockConstructMap {
+	SectionBlock: SectionBlock;
+	FieldBlock: FieldBlock;
+	FieldInline: FieldInline;
+	NaturalBlock: NaturalBlock;
+}
+
+/**
+ * Open registry of inline/expression-level constructs. Augment via declaration merging when new constructs land.
+ *
+ * @conventions-ignore Conventions: Typescript / Types / No Interface
+ */
+export interface InlineConstructMap {
+	NaturalExpression: NaturalExpression;
+	Tag: Tag;
+}
+
+/** Open registry of all constructs. */
+export type ConstructMap = BlockConstructMap & InlineConstructMap;
+
+export type BlockContent = BlockConstructMap[keyof BlockConstructMap];
+export type InlineContent = InlineConstructMap[keyof InlineConstructMap];
+
+export type Construct = ConstructMap[keyof ConstructMap];

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './factories/public';
+export * from './parser/public';
+export * from './serializer/public';

package/src/parser/constructs/FieldBlock/createFieldBlockParser.test.ts

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

package/src/parser/constructs/FieldBlock/createFieldBlockParser.ts

@@ -0,0 +1,9 @@
+import type { ConstructParserFactory } from '../../types';
+
+import { createFieldBlockIntegrator, createFieldBlockProcessor } from './private';
+
+export const createFieldBlockParser: ConstructParserFactory = () => ({
+	name: 'FieldBlock',
+	processor: createFieldBlockProcessor(),
+	integrator: createFieldBlockIntegrator(),
+});

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

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