erudit 3.0.0-dev.3 → 3.0.0-dev.5

package/test/bitran/link/target.test.ts

@@ -1,141 +1,141 @@
-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);
-        });
-    }
-});
+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 +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,
-        ),
-    );
-});
+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/tsconfig.json

@@ -1,8 +1,8 @@
-{
-    "extends": "../../playground/.erudit/nuxt/.nuxt/tsconfig.json",
-    "compilerOptions": {
-        "experimentalDecorators": true,
-        "emitDecoratorMetadata": true,
-        "types": ["@types/jest"]
-    }
-}
+{
+    "extends": "../../playground/.erudit/nuxt/.nuxt/tsconfig.json",
+    "compilerOptions": {
+        "experimentalDecorators": true,
+        "emitDecoratorMetadata": true,
+        "types": ["@types/jest"]
+    }
+}

package/utils/stress.ts

@@ -1,9 +1,9 @@
-import chalk, { type ChalkInstance } from 'chalk';
-
-export function stress(message: string, contentChalk?: ChalkInstance) {
-    return (
-        chalk.dim(`'`) +
-        (contentChalk ? contentChalk(message) : chalk.cyanBright(message)) +
-        chalk.dim(`'`)
-    );
-}
+import chalk, { type ChalkInstance } from 'chalk';
+
+export function stress(message: string, contentChalk?: ChalkInstance) {
+    return (
+        chalk.dim(`'`) +
+        (contentChalk ? contentChalk(message) : chalk.cyanBright(message)) +
+        chalk.dim(`'`)
+    );
+}

package/app/components/main/utils/ContentFlag.vue

@@ -1,15 +0,0 @@
-<script lang="ts" setup>
-import { computePosition, shift, autoUpdate, arrow } from '@floating-ui/dom';
-
-defineProps<{ icon: string; title: string }>();
-</script>
-
-<template>
-    <div :class="$style.flag">Content flag</div>
-</template>
-
-<style lang="scss" module>
-.flag {
-    color: red;
-}
-</style>