@erudit-js/core 4.2.0-dev.1 → 4.3.0-dev.1

package/dist/brandTerminal.js

@@ -1,4 +1,41 @@
-import gradient from 'gradient-string';
 import { brandColors, brandLogotype } from './brand.js';
-export const brandColorLogotype = gradient(brandColors).multiline(brandLogotype);
-export const brandColorTitle = gradient(brandColors)('Erudit');
+function hexToRgb(hex) {
+    const n = parseInt(hex.replace('#', ''), 16);
+    return [(n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff];
+}
+function lerp(a, b, t) {
+    return Math.round(a + (b - a) * t);
+}
+function colorChar(char, t, rgbColors) {
+    const segments = rgbColors.length - 1;
+    const scaled = t * segments;
+    const seg = Math.min(Math.floor(scaled), segments - 1);
+    const localT = scaled - seg;
+    const [r1, g1, b1] = rgbColors[seg];
+    const [r2, g2, b2] = rgbColors[seg + 1];
+    return `\x1b[38;2;${lerp(r1, r2, localT)};${lerp(g1, g2, localT)};${lerp(b1, b2, localT)}m${char}`;
+}
+/** Apply gradient across each line independently (matching gradient-string's .multiline()). */
+function gradientMultiline(text, colors) {
+    const rgbColors = colors.map(hexToRgb);
+    return text
+        .split('\n')
+        .map((line) => {
+        if (line.length === 0)
+            return line;
+        return ([...line]
+            .map((char, i) => colorChar(char, i / (line.length - 1 || 1), rgbColors))
+            .join('') + '\x1b[0m');
+    })
+        .join('\n');
+}
+/** Apply gradient across all characters in a single string. */
+function gradientText(text, colors) {
+    const rgbColors = colors.map(hexToRgb);
+    const chars = [...text];
+    const total = chars.length - 1 || 1;
+    return (chars.map((char, i) => colorChar(char, i / total, rgbColors)).join('') +
+        '\x1b[0m');
+}
+export const brandColorLogotype = gradientMultiline(brandLogotype, brandColors);
+export const brandColorTitle = gradientText('Erudit', brandColors);

package/dist/content/contributions.d.ts

@@ -1,7 +1,7 @@
 import type { GlobalContributorTypeguard } from '../contributor.js';
 export interface ConfigContributionDescribed {
     contributor: GlobalContributorTypeguard;
-    description: string;
+    description?: string;
 }
 export type ConfigContribution = GlobalContributorTypeguard | ConfigContributionDescribed;
 export type IContributable = {

package/dist/dependencies.d.ts

@@ -0,0 +1,7 @@
+export interface EruditDependency {
+    transpile?: boolean;
+    optimize?: boolean;
+}
+export type EruditDependencies = {
+    [dependencyName: string]: EruditDependency;
+};

package/dist/eruditConfig/config.d.ts

@@ -1,4 +1,4 @@
-import type { Nuxt } from '@nuxt/schema';
+import type { Nuxt } from 'nuxt/schema';
 import type { NitroConfig } from 'nitropack';
 import type { EruditIndexPage } from './indexPage.js';
 import type { EruditSponsors } from '../sponsor.js';
@@ -8,10 +8,10 @@ import type { EruditDebug } from './debug.js';
 import type { EruditRepository } from './repository.js';
 import type { EruditSeo } from './seo.js';
 import type { EruditLanguage } from './language.js';
-import type { EruditElements } from './elements.js';
 import type { EruditContributors } from '../contributor.js';
 import type { EruditAsideMajor } from './asideMajor.js';
 import type { EruditFavicons } from './favicons.js';
+import type { EruditDependencies } from '../dependencies.js';
 export interface EruditConfig {
     language?: EruditLanguage;
     debug?: EruditDebug;
@@ -29,18 +29,28 @@ export interface EruditConfig {
     sponsors?: EruditSponsors;
     seo?: EruditSeo;
     repository?: EruditRepository;
-    elements?: EruditElements;
+    elements?: string[];
     countElements?: (string | string[])[];
+    problemChecks?: string[];
+    /**
+     * Files whose named exports become globally available
+     * in all content files (no imports needed).
+     *
+     * Paths are resolved relative to the project root,
+     * just like `elements` and `problemChecks`.
+     *
+     * @example ['./my-globals']
+     */
+    autoImports?: string[];
+    dependencies?: EruditDependencies;
     /**
      * Erudit uses Nuxt under the hood.
      * Use this to alter Nuxt configuration.
      */
-    nuxtAugmentations?: [
-        ({ nuxt, nitro, projectPath, eruditPath, }: {
-            nuxt: Nuxt;
-            nitro: NitroConfig;
-            projectPath: string;
-            eruditPath: string;
-        }) => Promise<void> | void
-    ];
+    nuxtAugmentations?: (({ nuxt, nitro, projectPath, eruditPath, }: {
+        nuxt: Nuxt;
+        nitro: NitroConfig;
+        projectPath: string;
+        eruditPath: string;
+    }) => Promise<void> | void)[];
 }

package/dist/mode.d.ts

@@ -1 +1,2 @@
 export type EruditMode = 'dev' | 'write' | 'static';
+export declare function isDevLikeMode(mode: EruditMode): boolean;

package/dist/mode.js

@@ -1 +1,3 @@
-export {};
+export function isDevLikeMode(mode) {
+    return mode === 'dev' || mode === 'write';
+}

package/dist/problemCheck.d.ts

@@ -0,0 +1,24 @@
+export type ToProblemCheckDefinition<Name extends string, Data extends any> = {
+    name: Name;
+    Data: Data;
+};
+export type ProblemCheckDefinition = ToProblemCheckDefinition<string, any>;
+export declare function defineProblemCheck<Name extends string>(name: Name): <Data>() => ToProblemCheckDefinition<Name, Data>;
+export declare const ERUDIT_CHECK_PREFIX = "__ERUDIT_CHECK";
+export type ToProblemCheckObject<Definition extends ProblemCheckDefinition> = {
+    [ERUDIT_CHECK_PREFIX]: true;
+    name: Definition['name'];
+    data: Definition['Data'];
+};
+export type ProblemCheckObject = ToProblemCheckObject<ProblemCheckDefinition>;
+export declare function createProblemCheckObject<Definition extends ProblemCheckDefinition>(definition: Definition, data: Definition['Data']): ToProblemCheckObject<Definition>;
+export declare function isProblemCheckObject(obj: any): obj is ProblemCheckObject;
+export type ToProblemChecker<Definition extends ProblemCheckDefinition> = {
+    name: Definition['name'];
+    check: (data: Definition['Data'], input: string) => Promise<boolean> | boolean;
+};
+export type ProblemChecker = ToProblemChecker<ProblemCheckDefinition>;
+export type ProblemCheckers = {
+    [problemCheckName: string]: ProblemChecker;
+};
+export declare function defineProblemChecker<Definition extends ProblemCheckDefinition>(definition: Definition, handler: ToProblemChecker<Definition>['check']): ToProblemChecker<Definition>;

package/dist/problemCheck.js

@@ -0,0 +1,31 @@
+//
+// Problem Check Definition
+//
+export function defineProblemCheck(name) {
+    function finalizeProblemCheck() {
+        return {
+            name,
+        };
+    }
+    return finalizeProblemCheck;
+}
+//
+// Problem Check Object
+//
+export const ERUDIT_CHECK_PREFIX = '__ERUDIT_CHECK';
+export function createProblemCheckObject(definition, data) {
+    return {
+        [ERUDIT_CHECK_PREFIX]: true,
+        name: definition.name,
+        data,
+    };
+}
+export function isProblemCheckObject(obj) {
+    return obj?.[ERUDIT_CHECK_PREFIX] === true;
+}
+export function defineProblemChecker(definition, handler) {
+    return {
+        name: definition.name,
+        check: handler,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@erudit-js/core",
-  "version": "4.2.0-dev.1",
+  "version": "4.3.0-dev.1",
   "type": "module",
   "description": "Erudit core essentials",
   "exports": {
@@ -20,7 +20,6 @@
     "prepack": "bun run build"
   },
   "dependencies": {
-    "tsprose": "^1.0.0",
-    "gradient-string": "^3.0.0"
+    "tsprose": "^1.0.1"
   }
 }

package/dist/eruditConfig/elements.d.ts

@@ -1 +0,0 @@
-export type EruditElements = string[];