erudit 3.0.0-dev.6 → 3.0.0-dev.8

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,
-        ),
-    );
-});