erudit 2.0.0-dev.7

package/server/plugin/repository/topic.ts

@@ -0,0 +1,32 @@
+import type { TopicPart } from 'erudit-cog/schema';
+
+import { ERUDIT_SERVER } from '@server/global';
+import { DbTopic } from '@server/db/entities/Topic';
+import type { TopicPartLinks } from '@shared/content/data/type/topic';
+import { createTopicPartLink } from '@shared/link';
+
+export async function getTopicParts(contentId: string) {
+    const dbTopic = await ERUDIT_SERVER.DB.manager.findOne(DbTopic, {
+        select: ['parts'],
+        where: { contentId },
+    });
+
+    if (!dbTopic) throw new Error(`Missing topic "${contentId}".`);
+
+    return dbTopic.parts;
+}
+
+export async function getTopicPart(contentId: string): Promise<TopicPart> {
+    const topicParts = await getTopicParts(contentId);
+    return topicParts.shift()!;
+}
+
+export async function getTopicPartsLinks(topicId: string) {
+    const existingTopicParts = await getTopicParts(topicId);
+    const links: TopicPartLinks = {};
+
+    for (const topicPart of existingTopicParts)
+        links[topicPart] = createTopicPartLink(topicPart, topicId);
+
+    return links;
+}

package/server/tsconfig.json

@@ -0,0 +1,7 @@
+{
+    "extends": "../../../playground/.erudit/nuxt/.nuxt/tsconfig.server.json",
+    "compilerOptions": {
+        "verbatimModuleSyntax": true
+    },
+    "exclude": ["../module/**/*", "../globalPath.ts"]
+}

package/shared/aside/minor.ts

@@ -0,0 +1,50 @@
+import type { BitranLocation } from '../bitran/location';
+import type { Toc } from '../bitran/toc';
+import type { PreviousNextItem } from '../content/previousNext';
+import type { ContentContributor } from '../contributor';
+
+interface AsideMinorBase {
+    type: AsideMinorType;
+}
+
+export type AsideMinorType =
+    | 'topic'
+    | 'group'
+    | 'book'
+    | 'contributor'
+    | 'news';
+
+export interface AsideMinorTopic extends AsideMinorBase {
+    type: 'topic';
+    fullContentId: string;
+    location: BitranLocation;
+    nav: Partial<{
+        previous: PreviousNextItem;
+        next: PreviousNextItem;
+        article: string;
+        summary: string;
+        practice: string;
+    }>;
+    toc: Toc;
+    contributors?: ContentContributor[];
+    // todos: TodoItem[];
+}
+
+export interface AsideMinorContent extends AsideMinorBase {
+    type: 'group' | 'book';
+    fullContentId: string;
+    nav: Partial<{
+        previous: PreviousNextItem;
+        next: PreviousNextItem;
+    }>;
+    contributors?: ContentContributor[];
+}
+
+export interface AsideMinorNews extends AsideMinorBase {
+    type: 'news';
+}
+
+export type AsideMinorData =
+    | AsideMinorTopic
+    | AsideMinorContent
+    | AsideMinorNews;

package/shared/asset.ts

@@ -0,0 +1,15 @@
+export function eruditAsset(path: string) {
+    return '/_erudit-asset/' + path;
+}
+
+export function contributorAsset(path: string) {
+    return '/_user-asset/contributor/' + path;
+}
+
+export function contentAsset(path: string) {
+    return '/_user-asset/content/' + path;
+}
+
+export function publicAsset(path: string) {
+    return '/_user-asset/public/' + path;
+}

package/shared/bitran/alias.ts

@@ -0,0 +1,17 @@
+export type BitranAliases = Record<string, string>;
+
+export const NO_ALIASES: () => BitranAliases = () => ({});
+
+export function tryReplaceAlias(
+    target: string,
+    aliases: BitranAliases,
+): string {
+    if (!target.match(/^~\w+$/)) return target;
+
+    const alias = target.substring(1);
+    const replacement = aliases[alias];
+
+    if (!replacement) throw new Error(`Unknown alias "~${alias}"!`);
+
+    return replacement;
+}

package/shared/bitran/context.ts

@@ -0,0 +1,7 @@
+import type { BitranAliases } from './alias';
+import type { BitranLocation } from './location';
+
+export interface BitranContext {
+    location: BitranLocation;
+    aliases: BitranAliases;
+}

package/shared/bitran/location.ts

@@ -0,0 +1,166 @@
+import { isTopicPart } from 'erudit-cog/schema';
+
+export const bitranLocationTypes = {
+    article: true,
+    summary: true,
+    practice: true,
+    group: true,
+    contributor: true,
+};
+
+export type BitranLocationType = keyof typeof bitranLocationTypes;
+
+export function isBitranLocationType(type: any): type is BitranLocationType {
+    return type in bitranLocationTypes;
+}
+
+function typeRequiresPath(type: BitranLocationType) {
+    return bitranLocationTypes[type];
+}
+
+export interface BitranLocation {
+    type: BitranLocationType;
+    path?: string;
+    unique?: string;
+}
+
+export function stringifyBitranLocation(location: BitranLocation): string {
+    try {
+        if (!isBitranLocationType(location.type))
+            throw `Unknown Bitran location type "${location.type}"!`;
+
+        if (!location.path && typeRequiresPath(location.type))
+            throw 'Missing Bitran location path!';
+
+        if (location.unique === '')
+            throw 'Bitran location unique cannot be empty string!';
+    } catch (reason) {
+        let message = `${reason}\n\n` + JSON.stringify(location, null, 4);
+        throw new Error(message);
+    }
+
+    return (
+        location.type +
+        '|' +
+        (location.path || '') +
+        (location.unique ? '|' + location.unique : '')
+    );
+}
+
+export function parseBitranLocation(strLocation: string): BitranLocation {
+    const [strType, strPath, strUnique] = strLocation.split('|');
+
+    if (!isBitranLocationType(strType))
+        throw new Error(`Unknown Bitran location type "${strType}"!`);
+
+    const location: BitranLocation = { type: strType };
+
+    if (!strPath) {
+        if (typeRequiresPath(location.type))
+            throw new Error(
+                `Missing Bitran location path for type "${strType}"!`,
+            );
+    } else location.path = strPath;
+
+    if (strUnique === '')
+        throw `Bitran location "${strLocation}" unique cannot be empty string!`;
+    else if (strUnique) location.unique = strUnique;
+
+    return location;
+}
+
+export function parsePartialBitranLocation(
+    strLocation: string,
+    contextLocation: BitranLocation,
+): BitranLocation {
+    const parts = strLocation.split('|');
+
+    // Only unique provided. Restoring type + path
+    // function -> article|foo/bar|function
+    if (parts.length === 1)
+        return {
+            type: contextLocation.type,
+            path: contextLocation.path,
+            unique: parts[0],
+        };
+
+    if (parts.length === 2) {
+        //
+        // If there are two parts, the result depends on location type
+        //
+
+        // In topics we can reference topic parts without specifying content path
+        // practice|function -> practice|foo/bar|function
+        if (isTopicPart(parts[0])) {
+            const [type, unique] = parts as [BitranLocationType, string];
+
+            if (!isTopicPart(contextLocation.type))
+                throw new Error(
+                    `String Bitran location "${strLocation}" referencing topic part "${type}" in non-topic context!`,
+                );
+
+            return {
+                type,
+                path: contextLocation.path,
+                unique,
+            };
+        }
+    }
+
+    return parseBitranLocation(strLocation);
+}
+
+export const { encodeBitranLocation, decodeBitranLocation } = (() => {
+    const encodeSymbols = {
+        '|': '┃',
+        '/': '╱',
+        ':': '﹕',
+    };
+
+    const decodeSymbols = Object.entries(encodeSymbols).reduce(
+        (map, [key, value]) => ((map[value] = key), map),
+        {} as Record<string, string>,
+    );
+
+    const replaceSymbols = (text: string, symbols: Record<string, string>) => {
+        for (const [find, replace] of Object.entries(symbols))
+            text = text.replaceAll(find, replace);
+
+        return text;
+    };
+
+    return {
+        encodeBitranLocation: (strLocation: string) =>
+            replaceSymbols(strLocation, encodeSymbols),
+
+        decodeBitranLocation: (strLocation: string) =>
+            replaceSymbols(strLocation, decodeSymbols),
+    };
+})();
+
+export function locationFromPath(routePath: string) {
+    const pathParts = (
+        routePath.startsWith('/') ? routePath.substring(1) : routePath
+    ).split('/');
+    const firstPart = pathParts.shift() as any;
+    const locationPath = pathParts.join('/');
+
+    if (!locationPath) return undefined;
+
+    if (isTopicPart(firstPart))
+        return {
+            type: firstPart,
+            path: locationPath,
+        };
+
+    switch (firstPart) {
+        case 'group':
+        case 'contributor':
+            return {
+                type: firstPart,
+                path: locationPath,
+            };
+    }
+
+    return undefined;
+}

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

@@ -0,0 +1,46 @@
+import { BlockParseFactory, ProductStrFactory } from 'bitran/process';
+
+import type { BitranAliases } from '@erudit/shared/bitran/alias';
+import type { AliasType } from '../shared';
+
+export class AliasParser extends BlockParseFactory<AliasType> {
+    regexp = /^~ (?<alias>\S+) (?<target>\S+)$/;
+    aliases: BitranAliases = {};
+
+    canParse(strBlock: string) {
+        const lines = strBlock.split('\n');
+
+        for (const line of lines) {
+            const match = line.match(this.regexp);
+            if (!match) return false;
+            this.aliases[match[1]!.trim()] = match[2]!.trim();
+        }
+
+        return true;
+    }
+
+    async createParseData(): Promise<Record<string, string>> {
+        const { provide: context } = this.getPayload();
+
+        for (const [alias, target] of Object.entries(this.aliases)) {
+            if (alias in context.aliases)
+                throw new Error(
+                    `Duplicate alias "${alias}" within Bitran context!\n` +
+                        `Current alias target: "${target}".\n` +
+                        `Context alias target: "${context.aliases[alias]}".`,
+                );
+
+            context.aliases[alias] = target;
+        }
+
+        return this.aliases;
+    }
+}
+
+export class AliasStr extends ProductStrFactory<AliasType> {
+    stringifyData(data: Record<string, string>): string {
+        return Object.entries(data)
+            .map(([alias, location]) => `~ ${alias} ${location}`)
+            .join('\n');
+    }
+}

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

@@ -0,0 +1,13 @@
+import { BlockNode } from 'bitran/dom';
+import { defineProductCoreFn } from 'bitran/core';
+
+import type { AliasType } from '../shared';
+import { AliasParser, AliasStr } from './factory';
+
+export class AliasNode extends BlockNode<AliasType> {}
+
+export const defineAlias = defineProductCoreFn<AliasType>({
+    Node: AliasNode,
+    Parser: AliasParser,
+    Stringifier: AliasStr,
+});

package/shared/bitran/products/alias/render/Alias.vue

@@ -0,0 +1,10 @@
+<script lang="ts" setup>
+import type { ProductProps } from 'bitran/render';
+import type { AliasType } from '../shared';
+
+defineProps<ProductProps<AliasType>>();
+</script>
+
+<template>
+    <div>Alias</div>
+</template>

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

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 24 24">
+    <path d="M4.5,23.8c-.9,0-1.7-.3-2.3-.9-.6-.6-.9-1.4-.9-2.3s.3-1.7.9-2.3c.6-.6,1.4-.9,2.3-.9s1,.1,1.4.3c.4.2.8.5,1.1.9,1.1-.6,1.9-1.3,2.6-2.3s1.1-2,1.2-3.2h-3.3c-.2.6-.6,1.2-1.2,1.6-.6.4-1.2.6-1.9.6s-1.7-.3-2.3-.9c-.6-.6-.9-1.4-.9-2.3s.3-1.7.9-2.3c.6-.6,1.4-.9,2.3-.9s1.3.2,1.9.6c.6.4.9.9,1.2,1.6h3.3c-.2-1.2-.6-2.3-1.2-3.2s-1.5-1.7-2.6-2.3c-.3.4-.7.7-1.1.9-.4.2-.9.3-1.4.3-.9,0-1.7-.3-2.3-.9-.6-.6-.9-1.4-.9-2.3s.3-1.7.9-2.3C2.8.5,3.6.2,4.5.2s1.7.3,2.3.9.9,1.4,1,2.3c1.5.8,2.7,1.8,3.6,3.1s1.5,2.8,1.7,4.5h5.7l-1.7-1.7,1.5-1.5,4.3,4.3-4.3,4.3-1.5-1.5,1.7-1.7h-5.7c-.2,1.7-.8,3.1-1.7,4.5-.9,1.3-2.1,2.4-3.6,3.1,0,.9-.4,1.7-1,2.3-.6.6-1.4.9-2.3.9Z"/>
+</svg>

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

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

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

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

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

@@ -0,0 +1,5 @@
+import { defineLanguage } from 'bitran/render';
+
+export default defineLanguage({
+    _name: 'Перенаправления',
+});

package/shared/bitran/products/alias/shared.ts

@@ -0,0 +1,11 @@
+import type { DefineProductType } from 'bitran';
+
+import type { BitranAliases } from '@shared/bitran/alias';
+import type { BitranContext } from '@shared/bitran/context';
+
+export type AliasType = DefineProductType<{
+    ParseData: BitranAliases;
+    Provide: BitranContext;
+}>;
+
+export const aliasName = '__alias';

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

@@ -0,0 +1,53 @@
+import slugify from 'slugify';
+import { BlockParseFactory, ProductStrFactory } from 'bitran/process';
+
+import eruditConfig from '#erudit/config';
+import type { HeadingParseData, HeadingType } from '../shared';
+
+const validLevels = [1, 2, 3];
+
+export class HeadingParser extends BlockParseFactory<HeadingType> {
+    regexp = /^(?<level>#+) (?<title>.+)$/;
+    match?: RegExpMatchArray | null;
+
+    canParse(strBlock: string) {
+        this.match = strBlock.match(this.regexp);
+        return !!this.match;
+    }
+
+    async createParseData() {
+        const [, matchLevel, matchTitle] = this.match!;
+        const level = matchLevel!.length;
+        const title = matchTitle!.trim();
+
+        if (!validLevels.includes(level))
+            throw new Error(
+                `Invalid heading level: ${level}. Available levels: ${validLevels.join(', ')}.`,
+            );
+
+        if (!title) throw new Error(`Empty heading!`);
+
+        return {
+            level: level - 1,
+            title,
+        };
+    }
+
+    override alterAutoId(autoId: string) {
+        const { parseData, provide } = this.getPayload();
+
+        // TODO: If Chinese-like locale is set just return auto-id or original title?
+        let titleSlug = slugify(parseData.title, {
+            lower: true,
+            strict: true,
+            locale: provide?.languageCode || eruditConfig.language,
+        });
+        return titleSlug || autoId;
+    }
+}
+
+export class HeadingStr extends ProductStrFactory<HeadingType> {
+    stringifyData({ title, level }: HeadingParseData) {
+        return `${'#'.repeat(level + 1)} ${title}`;
+    }
+}

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

@@ -0,0 +1,19 @@
+import { defineProductCore, defineProductCoreFn } from 'bitran/core';
+import { BlockNode } from 'bitran/dom';
+
+import type { HeadingType } from '../shared';
+import { HeadingParser, HeadingStr } from './factory';
+
+export class HeadingNode extends BlockNode<HeadingType> {}
+
+export const heading = defineProductCore<HeadingType>({
+    Node: HeadingNode,
+    Parser: HeadingParser,
+    Stringifier: HeadingStr,
+});
+
+export const defineLocaleHeading = defineProductCoreFn<HeadingType>({
+    Node: HeadingNode,
+    Parser: HeadingParser,
+    Stringifier: HeadingStr,
+});

package/shared/bitran/products/heading/render/Heading.vue

@@ -0,0 +1,47 @@
+<script lang="ts" setup>
+import { useParseData, usePrettyText, type ProductProps } from 'bitran/render';
+import { type HeadingType } from '../shared';
+
+const { node } = defineProps<ProductProps<HeadingType>>();
+const { level, title } = useParseData(node);
+const pretty = usePrettyText();
+</script>
+
+<template>
+    <component :is="`h${level + 2}`" :class="$style.h">
+        {{ pretty(title) }}
+    </component>
+</template>
+
+<style lang="scss" module>
+h2, h3, h4
+{
+    &.h
+    {
+        font-weight: 700;
+    }
+}
+
+h2.h
+{
+    font-size: 1.55em;
+    border-bottom: 1px solid light-dark(#dedede, #323232);
+    padding-bottom: 10px;
+}
+
+h3.h
+{
+    font-size: 1.2em;
+}
+
+h4.h
+{
+    font-size: 1.05em;
+}
+
+// Dirty hack to add extra space before the heading
+:global(.bitran-blockContainer:not(:first-of-type)):has(:global(> .bitran-block > .bitran-blockMain) > .h)
+{
+    margin-top: calc(var(--bitran_blocksGap) * 1.25);
+}
+</style>

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

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512">
+    <path d="M181.3 32.4c17.4 2.9 29.2 19.4 26.3 36.8L197.8 128l95.1 0 11.5-69.3c2.9-17.4 19.4-29.2 36.8-26.3s29.2 19.4 26.3 36.8L357.8 128l58.2 0c17.7 0 32 14.3 32 32s-14.3 32-32 32l-68.9 0L325.8 320l58.2 0c17.7 0 32 14.3 32 32s-14.3 32-32 32l-68.9 0-11.5 69.3c-2.9 17.4-19.4 29.2-36.8 26.3s-29.2-19.4-26.3-36.8l9.8-58.7-95.1 0-11.5 69.3c-2.9 17.4-19.4 29.2-36.8 26.3s-29.2-19.4-26.3-36.8L90.2 384 32 384c-17.7 0-32-14.3-32-32s14.3-32 32-32l68.9 0 21.3-128L64 192c-17.7 0-32-14.3-32-32s14.3-32 32-32l68.9 0 11.5-69.3c2.9-17.4 19.4-29.2 36.8-26.3zM187.1 192L165.8 320l95.1 0 21.3-128-95.1 0z" />
+</svg>

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

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

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

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

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

@@ -0,0 +1,5 @@
+import { defineLanguage } from 'bitran/render';
+
+export default defineLanguage({
+    _name: 'Раздел',
+});

package/shared/bitran/products/heading/shared.ts

@@ -0,0 +1,13 @@
+import type { DefineProductType } from 'bitran';
+
+export interface HeadingParseData {
+    level: number;
+    title: string;
+}
+
+export type HeadingType = DefineProductType<{
+    ParseData: HeadingParseData;
+    Provide?: { languageCode: string };
+}>;
+
+export const headingName = '__heading';

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

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

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