erudit 3.0.0-dev.6 → 3.0.0-dev.7

package/shared/bitran/link/renderer.ts

@@ -1,21 +0,0 @@
-import {
-    defineElementVueRenderer,
-    defineComponent,
-    defineIcon,
-    defineLanguages,
-} from '@bitran-js/renderer-vue';
-
-import { LinkNode, type LinkSchema } from './shared';
-
-export const linkRenderer = defineElementVueRenderer<LinkSchema>({
-    Node: LinkNode,
-    component: defineComponent(() => import('./Link.vue')),
-    icon: defineIcon(() => import('./icon.svg?raw')),
-    languages: defineLanguages({
-        en: () => import('./languages/en'),
-        ru: () => import('./languages/ru'),
-    }),
-    createRenderData: async () => {
-        throw Error('Render data for Links must be built only on server side!');
-    },
-});

package/shared/bitran/link/shared.ts

@@ -1,17 +0,0 @@
-import { InlinerNode, type DefineElementSchema } from '@bitran-js/core';
-
-import type { LinkTarget } from './target';
-
-export const linkName = 'link';
-
-export interface LinkParseData {
-    target: string;
-    label: string;
-}
-
-export type LinkSchema = DefineElementSchema<{
-    ParseData: LinkParseData;
-    RenderData: LinkTarget;
-}>;
-
-export class LinkNode extends InlinerNode<LinkSchema> {}

package/shared/bitran/link/target.ts

@@ -1,134 +0,0 @@
-import { isTopicPart } from '@erudit-js/cog/schema';
-import { tryReplaceAlias } from '@erudit-js/bitran-elements/aliases/shared';
-
-import type { BitranContext } from '@shared/bitran/context';
-import {
-    bitranLocationTypes,
-    parsePartialBitranLocation,
-    stringifyBitranLocation,
-} from '@shared/bitran/location';
-
-export type LinkTargetType = 'unique' | 'page' | 'absolute' | 'external';
-
-interface LinkTargetBase {
-    type: LinkTargetType;
-}
-
-export interface UniqueLinkTarget extends LinkTargetBase {
-    type: 'unique';
-    strlocation: string;
-    _productName?: string;
-    _absoluteStrLocation?: string;
-    _href?: string;
-}
-
-export const linkTargetPageTypes = {
-    ...bitranLocationTypes,
-    // Custom page types, that does not have Bitran content
-    book: true,
-};
-
-export type LinkTargetPageType = keyof typeof linkTargetPageTypes;
-
-export function isLinkTargetPageType(
-    pageType: any,
-): pageType is LinkTargetPageType {
-    return pageType in linkTargetPageTypes;
-}
-
-function pageTypeRequiresPath(type: LinkTargetPageType) {
-    return linkTargetPageTypes[type];
-}
-
-export interface PageLinkTarget extends LinkTargetBase {
-    type: 'page';
-    pageType: LinkTargetPageType;
-    path?: string;
-    _href?: string;
-}
-
-export interface AbsoluteLinkTarget extends LinkTargetBase {
-    type: 'absolute';
-    href: string;
-}
-
-export interface ExternalLinkTarget extends LinkTargetBase {
-    type: 'external';
-    href: string;
-}
-
-export type LinkTarget =
-    | UniqueLinkTarget
-    | PageLinkTarget
-    | AbsoluteLinkTarget
-    | ExternalLinkTarget;
-
-export function createLinkTarget(
-    target: string,
-    context: BitranContext,
-): LinkTarget {
-    target = tryReplaceAlias(target, context.aliases);
-
-    if (target.startsWith('/'))
-        return {
-            type: 'absolute',
-            href: target,
-        };
-
-    try {
-        new URL(target);
-        return {
-            type: 'external',
-            href: target,
-        };
-    } catch {}
-
-    if (target.startsWith('page|')) {
-        let [, pageType, path] = target.split('|');
-
-        if (!isLinkTargetPageType(pageType))
-            throw new Error(
-                `Unknown page type "${pageType}" in link "${target}"!`,
-            );
-
-        if (!path) {
-            if (isTopicPart(pageType)) {
-                if (!isTopicPart(context.location.type))
-                    throw new Error(
-                        `Page link "${target}" is referencing topic part "${pageType}" without path in non-topic context!`,
-                    );
-
-                path = context.location.path;
-            } else {
-                if (pageTypeRequiresPath(pageType))
-                    throw new Error(
-                        `Page link "${target}" does not have a path!`,
-                    );
-            }
-        }
-
-        return {
-            type: 'page',
-            pageType,
-            path,
-        };
-    }
-
-    const location = parsePartialBitranLocation(target, context.location);
-
-    if (
-        !location.unique &&
-        isLinkTargetPageType(location.type) &&
-        !isTopicPart(location.type)
-    )
-        return {
-            type: 'page',
-            pageType: location.type,
-            path: location.path,
-        };
-
-    return {
-        type: 'unique',
-        strlocation: stringifyBitranLocation(location),
-    };
-}

package/shared/bitran/link/transpiler.ts

@@ -1,10 +0,0 @@
-import { defineElementTranspiler } from '@bitran-js/transpiler';
-
-import { LinkNode, type LinkSchema } from './shared';
-import { LinkParser, LinkStringifier } from './factory';
-
-export const linkTranspiler = defineElementTranspiler<LinkSchema>({
-    Node: LinkNode,
-    Parsers: [LinkParser],
-    Stringifier: LinkStringifier,
-});

package/shared/bitran/location.ts

@@ -1,166 +0,0 @@
-import { isTopicPart } from '@erudit-js/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/test/bitran/link/target.test.ts

@@ -1,141 +0,0 @@
-import { NO_ALIASES } from '@erudit-js/bitran-elements/aliases/shared';
-
-console.log(NO_ALIASES());
-
-import type { BitranContext } from '@erudit/shared/bitran/context';
-import {
-    createLinkTarget,
-    type AbsoluteLinkTarget,
-    type ExternalLinkTarget,
-    type LinkTargetType,
-    type PageLinkTarget,
-    type UniqueLinkTarget,
-} from '@erudit/shared/bitran/link/target';
-
-const articleContext: BitranContext = {
-    location: {
-        type: 'article',
-        path: 'a/b/c',
-    },
-    aliases: {
-        a1: 'alias1',
-    },
-};
-
-const contributorContext: BitranContext = {
-    location: {
-        type: 'contributor',
-        path: 'john',
-    },
-    aliases: NO_ALIASES(),
-};
-
-//
-//
-//
-
-const absoluteTargets = ['/', '/foo/bar/baz'];
-
-const externalTargets = [
-    'http://www.google.com',
-    'http://www.google.com/',
-    'https://www.google.com/foo/bar/baz',
-    'https://www.google.com/foo/bar/baz?a=1&b=2#anchor',
-];
-
-const validPageTargets: [string, Pick<PageLinkTarget, 'pageType' | 'path'>][] =
-    [
-        // With "page|" prefix
-        ['page|contributor|john', { pageType: 'contributor', path: 'john' }],
-        ['page|article|foo/bar', { pageType: 'article', path: 'foo/bar' }],
-        [
-            'page|book|combinatorics',
-            { pageType: 'book', path: 'combinatorics' },
-        ],
-        [
-            'page|summary',
-            { pageType: 'summary', path: articleContext.location.path },
-        ],
-        // Without "page|" prefix for non-topic parts
-        ['contributor|john', { pageType: 'contributor', path: 'john' }],
-    ];
-
-const invalidPageTargets = [
-    // Reference topic part in non-topic context
-    'page|article',
-    // Unknown page type
-    'page|foo|a/b/c',
-    // Unkown Bitran location type
-    'book|combinatorics',
-];
-
-const validUniqueTargets: [string, string][] = [
-    ['definition', 'article|a/b/c|definition'],
-    ['practice|term', 'practice|a/b/c|term'],
-    ['contributor|john|theorem', 'contributor|john|theorem'],
-];
-
-//
-//
-//
-
-describe('createLinkTarget', () => {
-    it.each(absoluteTargets)(
-        'should create absolute link target for %p',
-        (absoluteTarget) => {
-            const target = createLinkTarget(
-                absoluteTarget,
-                articleContext,
-            ) as AbsoluteLinkTarget;
-
-            expect(target.type).toBe<LinkTargetType>('absolute');
-            expect(target.href).toBe(absoluteTarget);
-        },
-    );
-
-    it.each(externalTargets)(
-        'should create external link target for %p',
-        (externalTarget) => {
-            const target = createLinkTarget(
-                externalTarget,
-                articleContext,
-            ) as ExternalLinkTarget;
-
-            expect(target.type).toBe<LinkTargetType>('external');
-            expect(target.href).toBe(externalTarget);
-        },
-    );
-
-    for (const [pageTarget, expected] of validPageTargets) {
-        it(`should create page link target for "${pageTarget}"`, () => {
-            const target = createLinkTarget(
-                pageTarget,
-                articleContext,
-            ) as PageLinkTarget;
-
-            expect(target.type).toBe<LinkTargetType>('page');
-            expect(target.pageType).toBe(expected.pageType);
-            expect(target.path).toBe(expected.path);
-        });
-    }
-
-    for (const invalidPageTarget of invalidPageTargets) {
-        it(`should throw on page link target "${invalidPageTarget}"`, () => {
-            expect(() =>
-                createLinkTarget(invalidPageTarget, contributorContext),
-            ).toThrow();
-        });
-    }
-
-    for (const [uniqueTarget, expected] of validUniqueTargets) {
-        it(`should create unique link target for "${uniqueTarget}"`, () => {
-            const target = createLinkTarget(
-                uniqueTarget,
-                articleContext,
-            ) as UniqueLinkTarget;
-
-            expect(target.type).toBe<LinkTargetType>('unique');
-            expect(target.strlocation).toBe(expected);
-        });
-    }
-});

package/test/bitran/location.test.ts

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