erudit 2.0.0-dev.7

package/shared/link.ts

@@ -0,0 +1,25 @@
+import type { ContentType, TopicPart } from 'erudit-cog/schema';
+import type { BitranLocation } from './bitran/location';
+
+export function createBitranLocationLink(location: BitranLocation) {
+    let link = `/${location.type}/${location.path}`;
+
+    if (location.unique) link += `#${location.unique}`;
+
+    return link;
+}
+
+export function createContentLink(contentType: ContentType, contentId: string) {
+    // if (contentType === 'topic')
+    //     throw Error(`Use 'createTopicPartLink' to create links to topics!`);
+
+    return `/${contentType}/${contentId}`;
+}
+
+export function createTopicPartLink(topicPart: TopicPart, contentId: string) {
+    return `/${topicPart}/${contentId}`;
+}
+
+export function createContributorLink(contributorId: string) {
+    return `/contributor/${contributorId}`;
+}

package/shared/types/language.ts

@@ -0,0 +1,75 @@
+export interface EruditPhrases {
+    _language_title: string;
+    _language_code: string;
+
+    site_info_title: string;
+    site_info_slogan: string;
+    seo_index_title: string;
+    seo_index_description: string;
+    seo_article_description: (contentTitle: string) => string;
+    seo_summary_description: (contentTitle: string) => string;
+    seo_practice_description: (contentTitle: string) => string;
+    index: string;
+    pages: string;
+    search: string;
+    language: string;
+    other: string;
+    ads_replacer: string;
+    theme: string;
+    theme_system: string;
+    theme_light: string;
+    theme_dark: string;
+    content: string;
+    generator: string;
+    main_page: string;
+    members: string;
+    add_translation: string;
+    empty_nav: string;
+    flag_dev: string;
+    flag_dev_description: string;
+    flag_advanced: string;
+    flag_advanced_description: string;
+    flag_secondary: string;
+    flag_secondary_description: string;
+    popover_dependencies: string;
+    popover_dependencies_description: string;
+    to_index: string;
+    about_book: string;
+    close: string;
+    back: string;
+    goto: string;
+    error: string;
+    external_link: string;
+    external_link_warn: string;
+    internal_link: string;
+    internal_link_warn: string;
+    book: string;
+    group: string;
+    topic: string;
+    article: string;
+    summary: string;
+    practice: string;
+    contributor: string;
+    element_id: string;
+    preview_missing_title: string;
+    preview_missing_explain: string;
+    preview_missing_explain_mismatch: string;
+    preview_hash_mismatch_title: string;
+    preview_hash_mismatch_explain: string;
+    current_page_hash: string;
+    expected_page_hash: string;
+    empty_toc: string;
+    contributors: string;
+    no_contributors: string;
+    make_contribution: string;
+    material_improvement: string;
+    how_to_improve: string;
+    edit_page: string;
+    report_problem: string;
+    references: string;
+    reference_source_featured: string;
+    references_description: string;
+}
+
+export type EruditPhraseId = keyof Partial<EruditPhrases>;
+export type EruditPhrase = EruditPhrases[keyof EruditPhrases];

package/shared/utils/objectsEqual.ts

@@ -0,0 +1,4 @@
+export function objectsEqual(a: any, b: any) {
+    const str = (obj: any) => JSON.stringify(obj)?.split('').sort().join('');
+    return str(a) === str(b);
+}

package/shared/utils/stringColor.ts

@@ -0,0 +1,9 @@
+export function stringColor(text: string) {
+    let hash = 0;
+
+    for (let i = 0; i < text.length; i++) {
+        hash = text.charCodeAt(i) + ((hash << 5) - hash);
+    }
+
+    return `hsl(${hash % 360}, 85%, 35%)`;
+}

package/test/bitran/alias.test.ts

@@ -0,0 +1,44 @@
+import { tryReplaceAlias } from '@erudit/shared/bitran/alias';
+
+const aliases = {
+    a1: 'foo',
+    a2: 'bar',
+    a3: 'baz',
+};
+
+const replaceTargets = ['~a1', '~a2', '~a3'];
+
+const noTouchTargets = [
+    'foo|bar|baz',
+    'https://www.google.com',
+    '~',
+    ' ~a1',
+    '~ a1',
+    '~a1 ',
+    '~a1 a2',
+];
+
+const throwTargets = ['~a4'];
+
+//
+//
+//
+
+describe('tryReplaceAlias', () => {
+    for (const target of replaceTargets) {
+        // @ts-ignore
+        const replaceValue = aliases[target.substring(1)];
+
+        it(`should replace target "${target}" with "${replaceValue}"`, () => {
+            expect(tryReplaceAlias(target, aliases)).toBe(replaceValue);
+        });
+    }
+
+    it.each(noTouchTargets)('should not change target "%s"', (target) => {
+        expect(tryReplaceAlias(target, aliases)).toBe(target);
+    });
+
+    it.each(throwTargets)('should throw on target "%s"', (target) => {
+        expect(() => tryReplaceAlias(target, aliases)).toThrow();
+    });
+});

package/test/bitran/location.test.ts

@@ -0,0 +1,143 @@
+import {
+    decodeBitranLocation,
+    encodeBitranLocation,
+    parseBitranLocation,
+    parsePartialBitranLocation,
+    stringifyBitranLocation,
+    type BitranLocation,
+} from '@erudit/shared/bitran/location';
+
+const locations: [BitranLocation, string][] = [
+    // Full locations
+    [{ type: 'article', path: 'foo', unique: 'bar' }, 'article|foo|bar'],
+    [{ type: 'group', path: 'foo', unique: 'bar' }, 'group|foo|bar'],
+    // Type + path
+    [{ type: 'article', path: 'foo' }, 'article|foo'],
+    [{ type: 'group', path: 'foo' }, 'group|foo'],
+];
+
+const partialLocations: [string, BitranLocation, BitranLocation][] = [
+    // Full string location
+    [
+        'article|foo/bar|baz',
+        { type: 'group', path: 'qux' },
+        { type: 'article', path: 'foo/bar', unique: 'baz' },
+    ],
+    // Only unique
+    [
+        'baz',
+        { type: 'summary', path: 'foo/bar' },
+        { type: 'summary', path: 'foo/bar', unique: 'baz' },
+    ],
+    [
+        'baz',
+        { type: 'contributor', path: 'John' },
+        { type: 'contributor', path: 'John', unique: 'baz' },
+    ],
+    // Topic context
+    [
+        'article|baz',
+        { type: 'practice', path: 'foo/bar' },
+        { type: 'article', path: 'foo/bar', unique: 'baz' },
+    ],
+];
+
+const invalidPartialLocations: [string, BitranLocation][] = [
+    // Referencing topic part in non-topic context
+    ['article|bar', { type: 'contributor', path: 'foo' }],
+];
+
+const invalidLocations = [
+    // Too few parts
+    { type: 'article' },
+    { path: 'foo' },
+    { unique: 'foo' },
+    // Unknown type
+    { type: 'foo' },
+    { type: 'foo', path: 'bar', unique: 'baz' },
+    // Locations that require path
+    { type: 'article', unique: 'foo' },
+    { type: 'summary', unique: 'foo' },
+    { type: 'practice', unique: 'foo' },
+    { type: 'group', unique: 'foo' },
+    { type: 'contributor', unique: 'foo' },
+];
+
+const invalidStrLocations = [
+    // Too few parts
+    'article',
+    'group',
+    // Unknown type
+    'foo',
+    'foo|bar',
+    'foo|bar|baz',
+    // Empty string unique
+    'article|foo/bar|',
+];
+
+//
+//
+//
+
+describe('stringifyBitranLocation', () => {
+    for (const [location, expected] of locations) {
+        it(`should produce "${expected}"`, () => {
+            expect(stringifyBitranLocation(location)).toBe(expected);
+        });
+    }
+
+    for (const invalidLocation of invalidLocations) {
+        it(`should throw on location ${JSON.stringify(invalidLocation)}`, () => {
+            expect(() =>
+                stringifyBitranLocation(invalidLocation as BitranLocation),
+            ).toThrow();
+        });
+    }
+});
+
+describe('parseBitranLocation', () => {
+    for (const [location, expected] of locations) {
+        it(`should produce ${JSON.stringify(expected)}`, () => {
+            expect(parseBitranLocation(expected)).toEqual(location);
+        });
+    }
+
+    for (const invalidStrLocation of invalidStrLocations) {
+        it(`should throw on location "${invalidStrLocation}"`, () => {
+            expect(() => parseBitranLocation(invalidStrLocation)).toThrow();
+        });
+    }
+});
+
+describe('parsePartialBitranLocation', () => {
+    for (const [locationStr, context, expected] of partialLocations) {
+        it(`should produce ${JSON.stringify(expected)}`, () => {
+            expect(parsePartialBitranLocation(locationStr, context)).toEqual(
+                expected,
+            );
+        });
+    }
+
+    for (const [locationStr, context] of invalidPartialLocations) {
+        it(`should throw on location "${locationStr}"`, () => {
+            expect(() =>
+                parsePartialBitranLocation(locationStr, context),
+            ).toThrow();
+        });
+    }
+});
+
+describe('decode/encodeBitranLocation', () => {
+    it.each([
+        '',
+        'foo',
+        'foo|bar',
+        'foo|bar|baz',
+        'foo|bar/baz|qux',
+        'foo|bar/baz/qux|corge:grault:waldo',
+    ])('should not change string location %p', (testCase) =>
+        expect(decodeBitranLocation(encodeBitranLocation(testCase))).toBe(
+            testCase,
+        ),
+    );
+});

package/test/bitran/products/alias.test.ts

@@ -0,0 +1,83 @@
+import { createBitranCore, ParagraphNode } from 'bitran/core';
+import { ErrorNode } from 'bitran/default';
+
+import { AliasNode, defineAlias } from '@shared/bitran/products/alias/core';
+import type { AliasType } from '@shared/bitran/products/alias/shared';
+
+const bitran = createBitranCore({
+    products: {
+        alias: defineAlias({
+            a1: 'context alias 1',
+            a3: 'context alias 3',
+        }),
+    },
+});
+
+test('Alias parse and stringify', async () => {
+    const text = `
+
+~ foo article|foo|bar
+
+~ bar article|foo|bar
+~ baz article|foo|bar
+
+    `;
+
+    const parsed = await bitran.parser.parse(text);
+
+    const data: AliasType['ParseData'][] = [
+        { foo: 'article|foo|bar' },
+        {
+            bar: 'article|foo|bar',
+            baz: 'article|foo|bar',
+        },
+    ];
+
+    expect(
+        parsed.children.map((node) => (node as AliasNode).parseData),
+    ).toEqual(data);
+
+    expect(bitran.stringifier.stringify(parsed)).toEqual(text.trim());
+});
+
+test('Fake aliases', async () => {
+    const text = `
+
+~ NoSpaceBetween
+
+~ foo targetFoo
+~ NoSpaceBetween
+
+~ NoSpaceBetween
+~ foo targetFoo
+
+Some text
+~ foo targetFoo
+
+~foo
+
+~ foo targetFoo
+Some text
+
+    `;
+
+    const paragraphs = (await bitran.parser.parse(text)).children;
+
+    for (const paragraph of paragraphs)
+        expect(paragraph).toBeInstanceOf(ParagraphNode);
+});
+
+test('Invalid aliases', async () => {
+    const text = `
+
+~ a1 <invalid>
+
+~ a2 fooTarget
+~ a3 <invalid>
+
+    `;
+
+    const aliases = (await bitran.parser.parse(text)).children;
+
+    for (const alias of aliases) expect(alias).toBeInstanceOf(ErrorNode);
+});

package/test/bitran/products/heading.test.ts

@@ -0,0 +1,119 @@
+import { ErrorNode } from 'bitran/default';
+import { createBitranCore, ParagraphNode } from 'bitran/core';
+
+import {
+    defineLocaleHeading,
+    heading,
+    HeadingNode,
+} from '@shared/bitran/products/heading/core';
+
+const bitran = createBitranCore({
+    products: {
+        heading,
+    },
+});
+
+test('Headings parse and stringify', async () => {
+    const text = `
+
+# Hello!
+
+## This is me.
+
+### All this is valid, event "with $special$ characters"!
+
+    `;
+
+    const parsed = await bitran.parser.parse(text);
+
+    expect(
+        parsed.children.map((node) => (node as HeadingNode).parseData),
+    ).toEqual([
+        { level: 0, title: 'Hello!' },
+        { level: 1, title: 'This is me.' },
+        {
+            level: 2,
+            title: 'All this is valid, event "with $special$ characters"!',
+        },
+    ]);
+
+    expect(bitran.stringifier.stringify(parsed)).toEqual(text.trim());
+});
+
+test('Invalid headings', async () => {
+    const text = `
+
+#### Just too many!
+
+    `;
+
+    const headings = (await bitran.parser.parse(text)).children;
+
+    for (const heading of headings) expect(heading).toBeInstanceOf(ErrorNode);
+});
+
+test('Paragraphs which tricks parser to think they are headings', async () => {
+    const text = `
+
+#
+
+###
+
+# Some
+text
+
+Some
+# text
+
+    `;
+
+    const paragraphs = (await bitran.parser.parse(text)).children;
+
+    for (const paragraph of paragraphs)
+        expect(paragraph).toBeInstanceOf(ParagraphNode);
+});
+
+test('Auto IDs with unset locale', async () => {
+    const text = `
+
+# Some long phrase
+
+# Containing-!#$%*():bad characters
+
+# И немного текста
+
+# Some long phrase
+
+    `;
+
+    const headings = (await bitran.parser.parse(text)).children;
+
+    expect(
+        headings.map((heading) => (heading as HeadingNode).generated.autoId),
+    ).toEqual([
+        'some-long-phrase',
+        'containing-dollarpercentbad-characters',
+        'i-nemnogo-teksta',
+        'some-long-phrase-',
+    ]);
+});
+
+test('Auto IDs with locale', async () => {
+    const text = `
+
+# Маленький Подъезд
+
+    `;
+
+    const localeBitran = createBitranCore({
+        products: {
+            heading: defineLocaleHeading({ languageCode: 'bg' }),
+        },
+    });
+
+    const headings = (await localeBitran.parser.parse(text)).children;
+
+    expect(
+        headings.map((heading) => (heading as HeadingNode).generated.autoId),
+    ).toEqual(['malenykiy-podaezd']);
+});

package/test/bitran/products/include.test.ts

@@ -0,0 +1,77 @@
+import { createBitranCore, ParagraphNode } from 'bitran/core';
+
+import { include, IncludeNode } from '@shared/bitran/products/include/core';
+import { includeName } from '@shared/bitran/products/include/shared';
+
+const bitranCore = createBitranCore({
+    products: {
+        [includeName]: include,
+    },
+});
+
+test('Includes parse and stringify', async () => {
+    const text = `
+
+<~ definition:set
+
+<~ group|triangle|theorem:pifagorean-theorem
+
+<~ summary|baz
+
+    `;
+
+    const parsed = await bitranCore.parser.parse(text);
+
+    const locations: string[] = [
+        'definition:set',
+        'group|triangle|theorem:pifagorean-theorem',
+        'summary|baz',
+    ];
+
+    expect(
+        parsed.children.map((node) => (node as IncludeNode).parseData.location),
+    ).toEqual(locations);
+
+    expect(bitranCore.stringifier.stringify(parsed)).toEqual(text.trim());
+});
+
+test('Resolved include parse and stringify', async () => {
+    const text = `
+
+@__include
+    location: foo
+    resolved: true
+    blocks: |
+        Paragraph 1
+
+        Paragraph 2
+
+    `;
+
+    const parsed = await bitranCore.parser.parse(text);
+
+    expect(bitranCore.stringifier.stringify(parsed)).toEqual(text.trim());
+});
+
+test('Invalid includes', async () => {
+    const text = `
+
+<~      
+
+<~
+
+<~ one two three
+
+<~ id
+text
+
+Some
+<~ id
+
+    `;
+
+    const paragraphs = (await bitranCore.parser.parse(text)).children;
+
+    for (const paragraph of paragraphs)
+        expect(paragraph).toBeInstanceOf(ParagraphNode);
+});

package/test/bitran/products/link/factory.test.ts

@@ -0,0 +1,30 @@
+import { createBitranCore } from 'bitran/core';
+
+import { link, LinkNode } from '@shared/bitran/products/link/core';
+import type { LinkData } from '@shared/bitran/products/link/shared';
+
+const bitran = createBitranCore({
+    products: {
+        link,
+    },
+});
+
+test('Link parse and stringify', async () => {
+    const text = `This [is](target1) long line <<of [text](target2)>>!`;
+
+    const parsed = await bitran.parser.parseInliners(text);
+
+    // @ts-ignore
+    const links = [parsed[1], parsed[3]['parseData'].children[1]];
+
+    for (const link of links) expect(link).toBeInstanceOf(LinkNode);
+
+    expect(links[0].parseData).toEqual(<LinkData>{
+        label: 'is',
+        target: 'target1',
+    });
+    expect(links[1].parseData).toEqual(<LinkData>{
+        label: 'text',
+        target: 'target2',
+    });
+});