erudit 3.0.0-dev.2 → 3.0.0-dev.21

package/shared/link.ts

@@ -1,25 +1,28 @@
-import type { ContentType, TopicPart } from 'erudit-cog/schema';
-import type { BitranLocation } from './bitran/location';
-
-export function createBitranLocationLink(location: BitranLocation) {
-    let link = `/${location.type}/${location.path}`;
-
-    if (location.unique) link += `#${location.unique}`;
-
-    return link;
-}
-
-export function createContentLink(contentType: ContentType, contentId: string) {
-    // if (contentType === 'topic')
-    //     throw Error(`Use 'createTopicPartLink' to create links to topics!`);
-
-    return `/${contentType}/${contentId}`;
-}
-
-export function createTopicPartLink(topicPart: TopicPart, contentId: string) {
-    return `/${topicPart}/${contentId}`;
-}
-
-export function createContributorLink(contributorId: string) {
-    return `/contributor/${contributorId}`;
-}
+import type {
+    BitranLocation,
+    ContentType,
+    TopicPart,
+} from '@erudit-js/cog/schema';
+
+export function createBitranLocationLink(location: BitranLocation) {
+    let link = `/${location.type}/${location.path}/`;
+
+    if (location.unique) link += `#${location.unique}`;
+
+    return link;
+}
+
+export function createContentLink(contentType: ContentType, contentId: string) {
+    // if (contentType === 'topic')
+    //     throw Error(`Use 'createTopicPartLink' to create links to topics!`);
+
+    return `/${contentType}/${contentId}/`;
+}
+
+export function createTopicPartLink(topicPart: TopicPart, contentId: string) {
+    return `/${topicPart}/${contentId}/`;
+}
+
+export function createContributorLink(contributorId: string) {
+    return `/contributor/${contributorId}/`;
+}

package/shared/popover.ts

@@ -0,0 +1,8 @@
+import type { MyIconName } from '#my-icons';
+
+export interface PopoverData {
+    icon: MyIconName | (string & {});
+    title: string;
+    description: string;
+    color: string;
+}

package/shared/types/language.ts

@@ -1,75 +1,84 @@
-export interface EruditPhrases {
-    _language_title: string;
-    _language_code: string;
-
-    site_info_title: string;
-    site_info_slogan: string;
-    seo_index_title: string;
-    seo_index_description: string;
-    seo_article_description: (contentTitle: string) => string;
-    seo_summary_description: (contentTitle: string) => string;
-    seo_practice_description: (contentTitle: string) => string;
-    index: string;
-    pages: string;
-    search: string;
-    language: string;
-    other: string;
-    ads_replacer: string;
-    theme: string;
-    theme_system: string;
-    theme_light: string;
-    theme_dark: string;
-    content: string;
-    generator: string;
-    main_page: string;
-    members: string;
-    add_translation: string;
-    empty_nav: string;
-    flag_dev: string;
-    flag_dev_description: string;
-    flag_advanced: string;
-    flag_advanced_description: string;
-    flag_secondary: string;
-    flag_secondary_description: string;
-    popover_dependencies: string;
-    popover_dependencies_description: string;
-    to_index: string;
-    about_book: string;
-    close: string;
-    back: string;
-    goto: string;
-    error: string;
-    external_link: string;
-    external_link_warn: string;
-    internal_link: string;
-    internal_link_warn: string;
-    book: string;
-    group: string;
-    topic: string;
-    article: string;
-    summary: string;
-    practice: string;
-    contributor: string;
-    element_id: string;
-    preview_missing_title: string;
-    preview_missing_explain: string;
-    preview_missing_explain_mismatch: string;
-    preview_hash_mismatch_title: string;
-    preview_hash_mismatch_explain: string;
-    current_page_hash: string;
-    expected_page_hash: string;
-    empty_toc: string;
-    contributors: string;
-    no_contributors: string;
-    make_contribution: string;
-    material_improvement: string;
-    how_to_improve: string;
-    edit_page: string;
-    report_problem: string;
-    references: string;
-    reference_source_featured: string;
-    references_description: string;
-}
-
-export type EruditPhraseId = keyof Partial<EruditPhrases>;
-export type EruditPhrase = EruditPhrases[keyof EruditPhrases];
+export interface EruditPhrases {
+    _language_title: string;
+    _language_code: string;
+
+    site_info_title: string;
+    site_info_slogan: string;
+    seo_index_title: string;
+    seo_index_description: string;
+    seo_article_description: (contentTitle: string) => string;
+    seo_summary_description: (contentTitle: string) => string;
+    seo_practice_description: (contentTitle: string) => string;
+    index: string;
+    pages: string;
+    search: string;
+    language: string;
+    other: string;
+    ads_replacer: string;
+    theme: string;
+    theme_system: string;
+    theme_light: string;
+    theme_dark: string;
+    content: string;
+    main_page: string;
+    contributors: string;
+    contributors_page_description: string;
+    contributors_page_invite: string;
+    become_contributor: string;
+    contributor: string;
+    contribution: string;
+    contributions_explain: (count: number) => string;
+    contributor_description: (name: string) => string;
+    editor: string;
+    add_translation: string;
+    empty_nav: string;
+    flag_dev: string;
+    flag_dev_description: string;
+    flag_advanced: string;
+    flag_advanced_description: string;
+    flag_secondary: string;
+    flag_secondary_description: string;
+    popover_dependencies: string;
+    popover_dependencies_description: string;
+    to_index: string;
+    about_book: string;
+    close: string;
+    back: string;
+    goto: string;
+    error: string;
+    external_link: string;
+    external_link_warn: string;
+    internal_link: string;
+    internal_link_warn: string;
+    book: string;
+    group: string;
+    topic: string;
+    article: string;
+    summary: string;
+    practice: string;
+    element_id: string;
+    preview_missing_title: string;
+    preview_missing_explain: string;
+    preview_missing_explain_mismatch: string;
+    preview_hash_mismatch_title: string;
+    preview_hash_mismatch_explain: string;
+    current_page_hash: string;
+    expected_page_hash: string;
+    empty_toc: string;
+    no_contributors: string;
+    make_contribution: string;
+    material_improvement: string;
+    how_to_improve: string;
+    edit_page: string;
+    report_problem: string;
+    references: string;
+    reference_source_featured: string;
+    references_description: string;
+    // Sponsors
+    sponsors: string;
+    sponsors_description: string;
+    become_sponsor: string;
+}
+
+export type EruditPhraseId = keyof Partial<EruditPhrases>;
+export type EruditPhrase = EruditPhrases[keyof EruditPhrases];

package/shared/utils/objectsEqual.ts

@@ -1,4 +1,4 @@
-export function objectsEqual(a: any, b: any) {
-    const str = (obj: any) => JSON.stringify(obj)?.split('').sort().join('');
-    return str(a) === str(b);
-}
+export function objectsEqual(a: any, b: any) {
+    const str = (obj: any) => JSON.stringify(obj)?.split('').sort().join('');
+    return str(a) === str(b);
+}

package/shared/utils/stringColor.ts

@@ -1,9 +1,9 @@
-export function stringColor(text: string) {
-    let hash = 0;
-
-    for (let i = 0; i < text.length; i++) {
-        hash = text.charCodeAt(i) + ((hash << 5) - hash);
-    }
-
-    return `hsl(${hash % 360}, 85%, 35%)`;
-}
+export function stringColor(text: string) {
+    let hash = 0;
+
+    for (let i = 0; i < text.length; i++) {
+        hash = text.charCodeAt(i) + ((hash << 5) - hash);
+    }
+
+    return `hsl(${hash % 360}, 85%, 35%)`;
+}

package/test/contentId.test.ts

@@ -0,0 +1,91 @@
+import {
+    toAbsoluteContentPath,
+    resolveContentPath,
+} from '@erudit/shared/bitran/contentId';
+
+describe('resolveContentPath', () => {
+    it('should handle empty paths', () => {
+        expect(resolveContentPath('')).toBe('');
+    });
+
+    it('should not change paths without special symbols', () => {
+        expect(resolveContentPath('foo/bar/baz')).toBe('foo/bar/baz');
+    });
+
+    it('should skip empty path parts', () => {
+        expect(resolveContentPath('/foo///bar/baz/')).toBe('foo/bar/baz');
+    });
+
+    it('should handle ".." parts', () => {
+        const testCases = [
+            ['foo/bar/../baz', 'foo/baz'],
+            ['../../../foo/bar/baz', 'foo/bar/baz'],
+            ['foo/../../../bar/baz', 'bar/baz'],
+            ['../../..', ''],
+        ];
+
+        for (const [input, expected] of testCases) {
+            expect(resolveContentPath(input!)).toBe(expected);
+        }
+    });
+
+    it('should handle "." parts', () => {
+        const testCases = [
+            ['.', ''],
+            ['./foo/bar/baz', 'foo/bar/baz'],
+            ['./foo/./bar', 'foo/bar'],
+            ['foo/./././bar', 'foo/bar'],
+        ];
+
+        for (const [input, expected] of testCases) {
+            expect(resolveContentPath(input!)).toBe(expected);
+        }
+    });
+
+    it('should handle paths with both "." and ".." parts', () => {
+        const testCases = [
+            ['./../.', ''],
+            ['foo/./../bar', 'foo/bar'],
+        ];
+
+        for (const [input, expected] of testCases) {
+            expect(resolveContentPath(input!)).toBe(expected);
+        }
+    });
+});
+
+describe('toAbsoluteContentPath', () => {
+    const bookIds = ['combinatorics', 'group/book'];
+
+    it('should not use context on absolute paths', () => {
+        expect(
+            toAbsoluteContentPath('/foo/bar/../baz', 'qux/vaz', bookIds),
+        ).toBe('foo/baz');
+    });
+
+    it('should fallback to absolute path if not inside book', () => {
+        expect(
+            toAbsoluteContentPath('~/foo/bar', 'unknown-book', bookIds),
+        ).toBe('foo/bar');
+    });
+
+    it('should correctly handle book-relative paths', () => {
+        expect(toAbsoluteContentPath('~/foo/bar', 'group/book', bookIds)).toBe(
+            'group/book/foo/bar',
+        );
+    });
+
+    it('should by default append context before given content id', () => {
+        const testCases = [
+            ['baz/qux', 'foo/bar', 'foo/bar/baz/qux'],
+            ['./baz/qux', 'foo/bar', 'foo/bar/baz/qux'],
+            ['../baz/qux', 'foo/bar', 'foo/baz/qux'],
+        ];
+
+        for (const [contentId, context, expected] of testCases) {
+            expect(toAbsoluteContentPath(contentId!, context!, bookIds)).toBe(
+                expected,
+            );
+        }
+    });
+});

package/test/utils/url.test.ts

@@ -0,0 +1,99 @@
+import { trailingSlash, normalizeUrl } from '../../utils/url';
+
+describe('trailingSlash', () => {
+    describe('when add is true', () => {
+        it('should add trailing slash to path without one', () => {
+            expect(trailingSlash('/path', true)).toBe('/path/');
+        });
+
+        it('should preserve trailing slash when path already has one', () => {
+            expect(trailingSlash('/path/', true)).toBe('/path/');
+        });
+
+        it('should return root path unchanged', () => {
+            expect(trailingSlash('/', true)).toBe('/');
+        });
+
+        it('should add trailing slash to empty path', () => {
+            expect(trailingSlash('', true)).toBe('/');
+        });
+    });
+
+    describe('when add is false', () => {
+        it('should remove trailing slash from path', () => {
+            expect(trailingSlash('/path/', false)).toBe('/path');
+        });
+
+        it('should preserve path without trailing slash', () => {
+            expect(trailingSlash('/path', false)).toBe('/path');
+        });
+
+        it('should return root path unchanged', () => {
+            expect(trailingSlash('/', false)).toBe('/');
+        });
+
+        it('should handle empty path', () => {
+            expect(trailingSlash('', false)).toBe('');
+        });
+    });
+});
+
+describe('normalizeUrl', () => {
+    describe('with protocol', () => {
+        it('should normalize multiple slashes in path', () => {
+            expect(
+                normalizeUrl('https://example.com//path//to///resource'),
+            ).toBe('https://example.com/path/to/resource');
+        });
+
+        it('should preserve protocol and domain', () => {
+            expect(normalizeUrl('https://example.com/path')).toBe(
+                'https://example.com/path',
+            );
+        });
+
+        it('should handle different protocols', () => {
+            expect(normalizeUrl('http://example.com//path')).toBe(
+                'http://example.com/path',
+            );
+        });
+
+        it('should handle custom protocols', () => {
+            expect(normalizeUrl('custom+protocol://example.com//path')).toBe(
+                'custom+protocol://example.com/path',
+            );
+        });
+    });
+
+    describe('without protocol', () => {
+        it('should normalize multiple slashes in relative path', () => {
+            expect(normalizeUrl('/path//to///resource')).toBe(
+                '/path/to/resource',
+            );
+        });
+
+        it('should handle single slash', () => {
+            expect(normalizeUrl('/')).toBe('/');
+        });
+
+        it('should normalize empty segments', () => {
+            expect(normalizeUrl('///')).toBe('/');
+        });
+
+        it('should handle path without leading slash', () => {
+            expect(normalizeUrl('path//to/resource')).toBe('path/to/resource');
+        });
+    });
+
+    describe('edge cases', () => {
+        it('should handle empty string', () => {
+            expect(normalizeUrl('')).toBe('');
+        });
+
+        it('should handle query parameters and fragments', () => {
+            expect(
+                normalizeUrl('https://example.com//path?query=1#fragment'),
+            ).toBe('https://example.com/path?query=1#fragment');
+        });
+    });
+});

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/contentPath.ts

@@ -0,0 +1,67 @@
+import { readdirSync, statSync } from 'fs';
+
+// A directory is considered a "content directory" if it contains book, group, or topic with a file having a .js or .ts extension.
+// When a directory qualifies as a content directory, its name is simplified by removing any leading digits and a '+' or '-' (e.g., "29+foo" becomes "foo").
+
+const contentFileRegex = /^(book|group|topic)\.(js|ts)$/i;
+
+function normalizePath(path: string): string {
+    return path.replace(/\\/g, '/');
+}
+
+export function isContentDirectory(directory: string): boolean {
+    if (!statSync(directory).isDirectory()) {
+        return false;
+    }
+
+    return readdirSync(directory).some((file) => {
+        return contentFileRegex.test(file);
+    });
+}
+
+export function getContentPath(path: string, cwd?: string): string {
+    path = normalizePath(path);
+    cwd = cwd ? normalizePath(cwd) : undefined;
+
+    const unresolvedParts = path.split('/').filter(Boolean);
+    const resolvedParts: string[] = [];
+
+    let currentPath = cwd || '';
+    while (unresolvedParts.length) {
+        const currentPart = unresolvedParts.shift()!;
+        currentPath += '/' + currentPart;
+        if (isContentDirectory(currentPath)) {
+            resolvedParts.push(currentPart.replace(/^\d+(?:\+|-)/, ''));
+        } else {
+            resolvedParts.push(currentPart);
+        }
+    }
+
+    return resolvedParts.join('/');
+}
+
+export function scanContentPaths(directory: string): Record<string, string> {
+    directory = normalizePath(directory);
+
+    const map: Record<string, string> = {};
+
+    function traverse(currentPath: string) {
+        const files = readdirSync(currentPath);
+
+        for (const file of files) {
+            const fullPath = currentPath + '/' + file;
+            const relativePath = fullPath.slice(directory.length + 1);
+            const stat = statSync(fullPath);
+
+            if (stat.isDirectory()) {
+                traverse(fullPath);
+            } else {
+                map[getContentPath(relativePath, directory)] = relativePath;
+            }
+        }
+    }
+
+    traverse(directory);
+
+    return map;
+}

package/utils/ext.ts

@@ -0,0 +1,41 @@
+export const imageExtensions = [
+    'png',
+    'jpg',
+    'jpeg',
+    'gif',
+    'webp',
+    'avif',
+] as const;
+
+export const videoExtensions = ['mp4', 'webm', 'ogg'] as const;
+
+export type FileType = 'image' | 'video' | 'unknown';
+
+export function detectFileType(filename: string): FileType {
+    const ext = filename.split('.').pop()?.toLowerCase();
+
+    if (ext) {
+        if (imageExtensions.includes(ext as (typeof imageExtensions)[number])) {
+            return 'image';
+        }
+
+        if (videoExtensions.includes(ext as (typeof videoExtensions)[number])) {
+            return 'video';
+        }
+    }
+
+    return 'unknown';
+}
+
+export function detectStrictFileType<T extends FileType>(
+    filename: string,
+    ...types: T[]
+): T {
+    const fileType = detectFileType(filename);
+    if (!types.includes(fileType as T)) {
+        throw new Error(
+            `Invalid file type "${fileType}" of file "${filename}"! Expected one of: ${types.join(', ')}.`,
+        );
+    }
+    return fileType as T;
+}

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/utils/url.ts

@@ -0,0 +1,23 @@
+export function trailingSlash(path: string, add: boolean): string {
+    if (path === '/') {
+        return '/';
+    }
+
+    if (add) {
+        return path.endsWith('/') ? path : `${path}/`;
+    }
+
+    return path.endsWith('/') ? path.slice(0, -1) : path;
+}
+
+export function normalizeUrl(url: string): string {
+    // Handle protocol and origin separately
+    const protocolMatch = url.match(/^([a-z][a-z\d+\-.]*:\/\/[^\/]+)/i);
+    const protocol = protocolMatch ? protocolMatch[1] : '';
+    const pathPart = protocol ? url.slice(protocol.length) : url;
+
+    // Normalize path by removing empty segments
+    const normalizedPath = pathPart.replace(/\/+/g, '/');
+
+    return protocol + normalizedPath;
+}

package/app/components/ads/BannerTemplate.vue

@@ -1,51 +0,0 @@
-<script lang="ts" setup>
-const props = defineProps<{
-    bannerId: string;
-}>();
-
-const { getElementId, registerBanner } = useDarkMagic();
-const phrase = await usePhrases('ads_replacer', '_language_code');
-
-onMounted(() => {
-    registerBanner(props.bannerId);
-});
-</script>
-
-<template>
-    <section :class="$style.darkMagicContainer">
-        <div :id="getElementId(bannerId)">
-            <div :class="$style.darkMagicReplacer">
-                <MyIcon name="pirate" />
-                <div v-html="phrase.ads_replacer"></div>
-            </div>
-        </div>
-    </section>
-</template>
-
-<style lang="scss" module>
-.darkMagicContainer {
-    --maxHeight: 300px;
-
-    > div {
-        width: 100%;
-        max-height: var(--maxHeight);
-    }
-}
-
-.darkMagicReplacer {
-    max-height: var(--maxHeight);
-    height: var(--maxHeight);
-    width: 100%;
-    background: var(--bgAccent);
-    box-shadow: 0px 0px 5px 0px rgba(0, 0, 0, 0.1) inset;
-    color: var(--textMuted);
-
-    @include dark {
-        box-shadow: 0px 0px 3px 1px rgba(white, 0.025) inset;
-    }
-
-    strong {
-        color: inherit;
-    }
-}
-</style>