erudit 2.0.0-dev.8 → 3.0.0-dev.1

package/shared/bitran/products/include/core/factory.ts

@@ -1,61 +0,0 @@
-import {
-    BlockParseFactory,
-    ObjBlockParseFactory,
-    ObjProductStrFactory,
-    ProductStrFactory,
-    type keyable,
-} from 'bitran/process';
-
-import { includeName, type IncludeData, type IncludeType } from '../shared';
-
-export class IncludeParser extends BlockParseFactory<IncludeType> {
-    regexp = /^<~ (\S+)$/;
-    location!: string;
-
-    canParse(strBlock: string) {
-        const match = strBlock.match(this.regexp);
-
-        if (match && match[1]) {
-            this.location = match[1];
-            return true;
-        }
-
-        return false;
-    }
-
-    async createParseData() {
-        return {
-            location: this.location,
-        };
-    }
-}
-
-export class ResolvedIncludeParser extends ObjBlockParseFactory<IncludeType> {
-    objName = includeName;
-
-    async parseDataFromObj(obj: keyable): Promise<IncludeData> {
-        if (obj.error) throw obj.error;
-
-        return {
-            location: obj.location,
-            resolved: true,
-            blocks: await this.parseBlocks(obj.blocks),
-        };
-    }
-}
-
-export class IncludeStr extends ProductStrFactory<IncludeType> {
-    stringifyData(data: IncludeData): string {
-        if (data.resolved) {
-            const obj: any = {};
-
-            obj.resolved = true;
-            obj.location = data.location;
-
-            if (data.error) obj.error = data.error;
-            else obj.blocks = this.stringify(data.blocks!);
-
-            return ObjProductStrFactory.strObjBlock(includeName, obj);
-        } else return `<~ ${data.location}`;
-    }
-}

package/shared/bitran/products/include/core/index.ts

@@ -1,13 +0,0 @@
-import { BlockNode } from 'bitran/dom';
-import { defineProductCore } from 'bitran/core';
-
-import type { IncludeType } from '../shared';
-import { IncludeParser, IncludeStr, ResolvedIncludeParser } from './factory';
-
-export class IncludeNode extends BlockNode<IncludeType> {}
-
-export const include = defineProductCore({
-    Node: IncludeNode,
-    Parser: [IncludeParser, ResolvedIncludeParser],
-    Stringifier: IncludeStr,
-});

package/shared/bitran/products/include/render/Include.vue

@@ -1,13 +0,0 @@
-<script lang="ts" setup>
-import { Render, useParseData, type ProductProps } from 'bitran/render';
-
-import type { IncludeType } from '../shared';
-
-const { node } = defineProps<ProductProps<IncludeType>>();
-const { blocks } = useParseData(node);
-</script>
-
-<template>
-    <Render v-if="blocks" v-for="node of blocks.children" :node />
-    <div v-else>Блоков нема</div>
-</template>

package/shared/bitran/products/include/render/icon.svg

@@ -1,3 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 24 24">
-    <path d="M0,13.3l8-8,1.9,1.9-4.8,4.8h12.9c.9,0,1.7-.3,2.4-1,.6-.6,1-1.4,1-2.4s-.3-1.7-1-2.4-1.4-1-2.4-1h-.7v-2.7h.7c1.7,0,3.1.6,4.2,1.7s1.7,2.6,1.7,4.2-.6,3.1-1.7,4.2-2.6,1.7-4.2,1.7H5.1s4.8,4.8,4.8,4.8l-1.9,1.9L0,13.3Z"/>
-</svg>

package/shared/bitran/products/include/render/index.ts

@@ -1,18 +0,0 @@
-import {
-    defineIcon,
-    defineLanguages,
-    defineProductComponent,
-    defineProductRender,
-    RenderMode,
-} from 'bitran/render';
-
-export const include = defineProductRender({
-    mode: RenderMode.Server,
-    component: defineProductComponent(() => import('./Include.vue')),
-    icon: defineIcon(() => import('./icon.svg?raw')),
-    customLayout: true,
-    languages: defineLanguages({
-        en: () => import('./languages/en'),
-        ru: () => import('./languages/ru'),
-    }),
-});

package/shared/bitran/products/include/render/languages/en.ts

@@ -1,5 +0,0 @@
-import { defineLanguage } from 'bitran/render';
-
-export default defineLanguage({
-    _name: 'Include',
-});

package/shared/bitran/products/include/render/languages/ru.ts

@@ -1,5 +0,0 @@
-import { defineLanguage } from 'bitran/render';
-
-export default defineLanguage({
-    _name: 'Вставка',
-});

package/shared/bitran/products/include/shared.ts

@@ -1,15 +0,0 @@
-import type { DefineProductType } from 'bitran';
-import type { BlocksNode } from 'bitran/default';
-
-export interface IncludeData {
-    location: string;
-    resolved?: boolean;
-    blocks?: BlocksNode;
-    error?: any;
-}
-
-export type IncludeType = DefineProductType<{
-    ParseData: IncludeData;
-}>;
-
-export const includeName = '__include';

package/shared/bitran/products/link/core/factory.ts

@@ -1,20 +0,0 @@
-import { ProductStrFactory, RegexpInlinerParseFactory } from 'bitran/process';
-
-import type { LinkData, LinkType } from '../shared';
-
-export class LinkParser extends RegexpInlinerParseFactory<LinkType> {
-    regexp = /\[(.+?)\]\((.+?)\)/gm;
-
-    async parseDataFromRegexp(match: RegExpExecArray) {
-        return {
-            label: match[1]!,
-            target: match[2]!,
-        };
-    }
-}
-
-export class LinkStr extends ProductStrFactory<LinkType> {
-    stringifyData(parseData: LinkData) {
-        return `[${parseData.label}](${parseData.target})`;
-    }
-}

package/shared/bitran/products/link/core/index.ts

@@ -1,17 +0,0 @@
-import { InlinerNode } from 'bitran/dom';
-import { defineProductCore } from 'bitran/core';
-
-import type { LinkType } from '../shared';
-import { LinkParser, LinkStr } from './factory';
-
-export class LinkNode extends InlinerNode<LinkType> {}
-
-export const link = defineProductCore<LinkType>({
-    Node: LinkNode,
-    Parser: LinkParser,
-    Stringifier: LinkStr,
-    renderDataSide: 'pre',
-    buildRenderData: async () => {
-        throw Error('Cache for Links must be built only on server!');
-    },
-});

package/shared/bitran/products/link/render/index.ts

@@ -1,17 +0,0 @@
-import {
-    defineIcon,
-    defineLanguages,
-    defineProductComponent,
-    defineProductRender,
-    RenderMode,
-} from 'bitran/render';
-
-export const link = defineProductRender({
-    mode: RenderMode.Server,
-    component: defineProductComponent(() => import('./Link.vue')),
-    icon: defineIcon(() => import('./icon.svg?raw')),
-    languages: defineLanguages({
-        en: () => import('./languages/en'),
-        ru: () => import('./languages/ru'),
-    }),
-});

package/shared/bitran/products/link/render/languages/en.ts

@@ -1,5 +0,0 @@
-import { defineLanguage } from 'bitran/render';
-
-export default defineLanguage({
-    _name: 'Link',
-});

package/shared/bitran/products/link/render/languages/ru.ts

@@ -1,5 +0,0 @@
-import { defineLanguage } from 'bitran/render';
-
-export default defineLanguage({
-    _name: 'Ссылка',
-});

package/shared/bitran/products/link/shared.ts

@@ -1,15 +0,0 @@
-import type { DefineProductType } from 'bitran';
-
-import type { LinkTarget } from './target';
-
-export interface LinkData {
-    target: string;
-    label: string;
-}
-
-export type LinkType = DefineProductType<{
-    ParseData: LinkData;
-    RenderData: LinkTarget;
-}>;
-
-export const linkName = '__link';

package/test/bitran/alias.test.ts

@@ -1,44 +0,0 @@
-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/products/alias.test.ts

@@ -1,83 +0,0 @@
-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

@@ -1,119 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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',
-    });
-});