@mxfb/tools 1.0.0 → 1.0.2

package/TODO.md

@@ -0,0 +1 @@
+# To do

package/agnostic/@publisher/index.d.ts

@@ -0,0 +1,47 @@
+import { Core, type EndpointName, type ContractOf, type BodyOf, type ParamsOf, type QueryOf, type FileFieldsOf, type ResponseOf, type ErrorResponseOf } from '@design-edito/publisher';
+type Options<E extends EndpointName> = (BodyOf<E> extends null ? {} : {
+    body: BodyOf<E>;
+}) & (QueryOf<E> extends null ? {} : {
+    query: QueryOf<E>;
+}) & (ParamsOf<E> extends null ? {} : {
+    params: ParamsOf<E>;
+}) & (FileFieldsOf<E> extends null ? {} : {
+    files: Partial<Record<NonNullable<FileFieldsOf<E>>, Array<File>>>;
+});
+type IsOptionsOptional<E extends EndpointName> = BodyOf<E> extends null ? (QueryOf<E> extends null ? (ParamsOf<E> extends null ? (FileFieldsOf<E> extends null ? true : false) : false) : false) : false;
+type FormattedResponse<E extends EndpointName> = undefined | Blob | ResponseOf<E>;
+type FetchParams<E extends EndpointName> = IsOptionsOptional<E> extends true ? [endpoint: E, options?: Options<E>, previousErrors?: Core.Errors.Codes[]] : [endpoint: E, options: Options<E>, previousErrors?: Core.Errors.Codes[]];
+type OnRequestCallback = (request: {
+    url: string;
+    endpoint: EndpointName;
+    requestInit: RequestInit;
+}) => void;
+type OnResponseCallback = (response: FormattedResponse<EndpointName>, request: {
+    url: string;
+    endpoint: EndpointName;
+    requestInit: RequestInit;
+}) => void;
+type RequesterOptions = {
+    onRequest?: OnRequestCallback;
+    onResponse?: OnResponseCallback;
+    accessTokenLocalStorageKey?: string;
+};
+export default class Requester {
+    private baseUrl;
+    private onRequest;
+    private onResponse;
+    private storedAccessTokenKey;
+    private csrfToken;
+    private accessToken;
+    constructor(baseUrl: string, options?: RequesterOptions);
+    private setCsrfToken;
+    private setAccessToken;
+    private getServerResponse;
+    private csrfRefreshPromise;
+    private formatServerResponse;
+    private refreshCsrfToken;
+    private refreshAccessToken;
+    fetch<E extends EndpointName>(...args: FetchParams<E>): Promise<ContractOf<E>['type'] extends 'void' ? undefined | ErrorResponseOf<E> : ContractOf<E>['type'] extends 'file' ? Blob | ErrorResponseOf<E> : ResponseOf<E>>;
+    private contractsDetails;
+}
+export { Requester };

package/agnostic/@publisher/index.js

@@ -0,0 +1,361 @@
+/* Linting is suspended on this file: 44 of its 74 findings come from the deferred
+   conditional response type and cannot be fixed without reworking it. See « Two files
+   opted out of linting » in README.md before removing this. */
+/* eslint-disable
+  @typescript-eslint/array-type,
+  @typescript-eslint/class-methods-use-this,
+  @typescript-eslint/consistent-type-assertions,
+  @typescript-eslint/dot-notation,
+  @typescript-eslint/explicit-function-return-type,
+  @typescript-eslint/no-empty-object-type,
+  @typescript-eslint/no-explicit-any,
+  @typescript-eslint/no-unnecessary-condition,
+  @typescript-eslint/no-unnecessary-type-assertion,
+  @typescript-eslint/no-unsafe-argument,
+  @typescript-eslint/no-unsafe-assignment,
+  @typescript-eslint/no-unsafe-member-access,
+  @typescript-eslint/no-unsafe-return,
+  @typescript-eslint/no-unsafe-type-assertion,
+  @typescript-eslint/prefer-nullish-coalescing,
+  @typescript-eslint/prefer-readonly,
+  @typescript-eslint/return-await,
+  @typescript-eslint/strict-boolean-expressions,
+  object-shorthand,
+  preserve-caught-error,
+  require-unicode-regexp
+*/
+import { minutes } from '@design-edito/tools/agnostic/time/duration/index.js';
+import { unknownToString } from '@design-edito/tools/agnostic/errors/unknown-to-string/index.js';
+import { Core, Endpoint } from '@design-edito/publisher';
+const { Codes } = Core.Errors;
+export default class Requester {
+    baseUrl;
+    onRequest;
+    onResponse;
+    storedAccessTokenKey;
+    csrfToken = { value: null, fetchedAt: null };
+    accessToken = { value: null, fetchedAt: null };
+    constructor(baseUrl, options) {
+        this.baseUrl = baseUrl;
+        this.onRequest = options?.onRequest;
+        this.onResponse = options?.onResponse;
+        this.fetch = this.fetch.bind(this);
+        this.storedAccessTokenKey = options?.accessTokenLocalStorageKey ?? 'access_token';
+        const storedToken = localStorage.getItem(`${this.storedAccessTokenKey}/value`);
+        const storedFetchedAt = localStorage.getItem(`${this.storedAccessTokenKey}/fetchedAt`);
+        if (storedToken) {
+            this.accessToken.value = storedToken;
+            this.accessToken.fetchedAt = storedFetchedAt ? parseInt(storedFetchedAt) : null;
+        }
+    }
+    setCsrfToken(token) {
+        // console.group('setCsrfToken')
+        // console.log('->', token)
+        this.csrfToken.value = token;
+        this.csrfToken.fetchedAt = token !== null ? Date.now() : null;
+        // console.log('<-', this.csrfToken)
+        // console.groupEnd()
+    }
+    setAccessToken(token) {
+        // console.group('setAccessToken')
+        // console.log('->', token)
+        this.accessToken.value = token;
+        const fetchedAt = Date.now();
+        this.accessToken.fetchedAt = token !== null ? fetchedAt : null;
+        if (token !== null) {
+            localStorage.setItem(`${this.storedAccessTokenKey}/value`, token);
+            localStorage.setItem(`${this.storedAccessTokenKey}/fetchedAt`, `${fetchedAt}`);
+        }
+        else {
+            localStorage.removeItem(`${this.storedAccessTokenKey}/value`);
+            localStorage.removeItem(`${this.storedAccessTokenKey}/fetchedAt`);
+        }
+        // console.log('<-', this.accessToken)
+        // console.groupEnd()
+    }
+    async getServerResponse(...args) {
+        // console.group('getServerResponse')
+        const [endpoint, options = {}] = args;
+        // console.log('->', { endpoint, options })
+        // Route
+        const route = Endpoint[endpoint];
+        // Method
+        const [rawMethod, ...rawPathColonSplitted] = route.split(':');
+        const method = rawMethod?.toUpperCase() ?? '';
+        if (method !== 'GET'
+            && method !== 'POST'
+            && method !== 'PUT'
+            && method !== 'DELETE')
+            throw new Error(`Invalid method: ${method}`);
+        // Path
+        const pathChunks = rawPathColonSplitted
+            .join(':')
+            .replace(/^\/+/, '')
+            .split('/');
+        const path = pathChunks.join('/');
+        // Payload
+        const { body: rawBody, query: rawQuery, params: rawParams, files: rawFiles } = options;
+        const { type, upload } = this.contractsDetails[endpoint];
+        const body = rawBody ?? undefined;
+        const query = rawQuery ?? undefined;
+        const params = (rawParams ?? undefined);
+        const files = rawFiles ?? {};
+        // Params
+        let pathString = path;
+        pathString = pathString.replace(/:([A-Za-z0-9_]+)/g, (_, key) => {
+            return params?.[key] !== undefined
+                ? params[key]
+                : `:${key}`;
+        });
+        // Query
+        let queryString = '';
+        Object
+            .entries(query ?? {})
+            .forEach(([key, value]) => {
+            const val = Array.isArray(value) ? value : [value];
+            val.forEach(v => {
+                queryString += `${key}=${v}&`;
+            });
+        });
+        queryString = queryString.slice(0, -1);
+        // URL
+        const url = new URL(pathString, this.baseUrl);
+        url.search = queryString;
+        // Form data
+        const formData = new FormData();
+        Object
+            .entries(files)
+            .forEach(([key, value]) => value?.forEach(file => formData.append(key, file)));
+        formData.append('_json', JSON.stringify(body ?? {}));
+        // Fetch
+        const headers = {};
+        if (this.accessToken.value !== null) {
+            headers['Authorization'] = `Bearer ${this.accessToken.value}`;
+        }
+        if (this.csrfToken.value !== null) {
+            headers['x-csrf-token'] = this.csrfToken.value;
+        }
+        if (!upload) {
+            headers['Content-Type'] = 'application/json';
+        }
+        if (type === 'file') {
+            headers['Accept'] = 'application/octet-stream';
+        }
+        else if (type === 'void') {
+            delete headers['Accept'];
+        }
+        else if (type === 'json') {
+            headers['Accept'] = 'application/json';
+        }
+        else if (type === 'list') {
+            headers['Accept'] = 'application/json';
+        }
+        else {
+            throw new Error(`Invalid type: ${type}`);
+        }
+        const reqUrl = url.toString();
+        const requestInit = {
+            method,
+            credentials: 'include',
+            body: method !== 'GET'
+                ? (upload ? formData : JSON.stringify(body ?? {}))
+                : undefined,
+            headers: headers
+        };
+        // console.log({ url, endpoint, headers })
+        const requestData = { url: reqUrl, endpoint, requestInit };
+        this.onRequest?.(requestData);
+        const res = await window.fetch(reqUrl, requestInit);
+        // Check returned access tokens
+        const rawAccessToken = res.headers.get('x-access-token');
+        // console.log({ respondedToken: rawAccessToken })
+        if (rawAccessToken !== null) {
+            const accessToken = rawAccessToken.split(/\s+/g).at(1) ?? null;
+            if (accessToken !== this.accessToken.value)
+                this.setAccessToken(accessToken);
+        }
+        const formattedResponse = await this.formatServerResponse(res, type);
+        this.onResponse?.(formattedResponse, requestData);
+        // console.log('<-', res)
+        // console.groupEnd()
+        return res;
+    }
+    csrfRefreshPromise = null;
+    async formatServerResponse(res, type) {
+        if (type === 'void')
+            return res.status === 204
+                ? undefined
+                : await res.clone().json();
+        else if (type === 'file') {
+            const contentType = res.headers.get('Content-Type');
+            if (contentType === 'application/json')
+                return await res.clone().json();
+            return await res.blob();
+        }
+        else if (type === 'json')
+            return await res.clone().json();
+        else if (type === 'list')
+            return await res.clone().json();
+        else
+            throw new Error(`Invalid endpoint type: ${type}`);
+    }
+    async refreshCsrfToken() {
+        // console.group('refreshCsrfToken')
+        if (this.csrfRefreshPromise !== null) {
+            // console.log('already pending')
+            // console.groupEnd()
+            return this.csrfRefreshPromise;
+        }
+        this.csrfRefreshPromise = (async () => {
+            const res = await this.getServerResponse('CSRF_GET_TOKEN');
+            const formattedRes = await this.formatServerResponse(res, 'json');
+            if (!res.ok || !formattedRes.success) {
+                this.setCsrfToken(null);
+                return false;
+            }
+            const newToken = formattedRes.payload.token;
+            this.setCsrfToken(newToken);
+            return true;
+        })().finally(() => {
+            this.csrfRefreshPromise = null;
+        });
+        // console.log(this.csrfRefreshPromise)
+        // console.groupEnd()
+        return this.csrfRefreshPromise;
+    }
+    async refreshAccessToken() {
+        // console.group('refreshAccessToken')
+        const res = await this.getServerResponse('AUTH_REFRESH_TOKEN');
+        if (!res.ok) {
+            this.setAccessToken(null);
+            // console.groupEnd()
+            return false;
+        }
+        const rawToken = res.headers.get('x-access-token');
+        if (rawToken === null) {
+            this.setAccessToken(null);
+            // console.groupEnd()
+            return false;
+        }
+        const token = rawToken.split(/\s+/g).at(1) ?? '';
+        if (token !== this.accessToken.value)
+            this.setAccessToken(token);
+        // console.groupEnd()
+        return true;
+    }
+    async fetch(...args) {
+        // console.group('fetch')
+        const [endpoint, optionsOrPrevErrors = {}, _previousErrors = []] = args;
+        const options = Array.isArray(optionsOrPrevErrors)
+            ? {}
+            : optionsOrPrevErrors;
+        const previousErrors = Array.isArray(optionsOrPrevErrors)
+            ? optionsOrPrevErrors
+            : _previousErrors;
+        // console.log('->', { endpoint, options, previousErrors })
+        const { type, auth } = this.contractsDetails[endpoint];
+        // Refresh CSRF token if needed
+        const now = Date.now();
+        if (this.csrfToken.value === null
+            || this.csrfToken.fetchedAt === null
+            || now - this.csrfToken.fetchedAt > minutes(20).toMilliseconds())
+            await this.refreshCsrfToken();
+        // Refresh access token if needed
+        if (auth !== 'none' && this.accessToken.value === null)
+            await this.refreshAccessToken();
+        let res;
+        let formatted;
+        try {
+            res = await this.getServerResponse(endpoint, options);
+            formatted = await this.formatServerResponse(res, type);
+            if (endpoint === 'AUTH_LOGOUT'
+                || endpoint === 'AUTH_LOGOUT_EVERYWHERE')
+                this.setAccessToken(null);
+        }
+        catch (err) {
+            throw new Error(`Request failed: ${unknownToString(err)}`);
+        }
+        if (formatted === undefined) { /*console.log('<-', formatted); console.groupEnd(); */
+            return formatted;
+        }
+        if (formatted instanceof Blob) { /*console.log('<-', formatted); console.groupEnd(); */
+            return formatted;
+        }
+        if (formatted.success) { /*console.log('<-', formatted); console.groupEnd();*/
+            return formatted;
+        }
+        if (previousErrors.includes(formatted.error.code)) { /*console.log('<-', formatted); console.groupEnd();*/
+            return formatted;
+        }
+        const newPreviousErrors = [...previousErrors, formatted.error.code];
+        // Invalid CSRF token
+        if (formatted.error.code === Codes.INVALID_CSRF_TOKEN) {
+            await this.refreshCsrfToken();
+            // console.log('<-', formatted)
+            // console.groupEnd()
+            return this.fetch(endpoint, options, newPreviousErrors);
+        }
+        // Invalid access token
+        if (formatted.error.code === Codes.INVALID_ACCESS_TOKEN) {
+            await this.refreshAccessToken();
+            // console.log('<-', formatted)
+            // console.groupEnd()
+            return this.fetch(endpoint, options, newPreviousErrors);
+        }
+        // console.log('<-', formatted)
+        // console.groupEnd()
+        return formatted;
+    }
+    contractsDetails = {
+        // Core
+        ADMIN_TEMP_FLUSH: { type: 'void', auth: 'strong', upload: false },
+        ADMIN_USERS_CREATE: { type: 'json', auth: 'strong', upload: false },
+        ADMIN_USERS_DELETE: { type: 'json', auth: 'strong', upload: false },
+        ADMIN_USERS_GET: { type: 'json', auth: 'strong', upload: false },
+        ADMIN_USERS_GET_UPLOAD_QUOTA: { type: 'json', auth: 'strong', upload: false },
+        ADMIN_USERS_LIST: { type: 'list', auth: 'strong', upload: false },
+        ADMIN_USERS_RESET_UPLOAD_QUOTA: { type: 'json', auth: 'strong', upload: false },
+        ADMIN_USERS_REVOKE_AUTH_TOKENS: { type: 'void', auth: 'strong', upload: false },
+        ADMIN_USERS_REVOKE_EMAIL_VALIDATION_TOKENS: { type: 'void', auth: 'strong', upload: false },
+        ADMIN_USERS_REVOKE_PASSWORD_RENEWAL_TOKENS: { type: 'void', auth: 'strong', upload: false },
+        ADMIN_USERS_UPDATE: { type: 'json', auth: 'strong', upload: false },
+        AUTH_LOGIN: { type: 'json', auth: 'none', upload: false },
+        AUTH_LOGOUT: { type: 'void', auth: 'weak', upload: false },
+        AUTH_LOGOUT_EVERYWHERE: { type: 'void', auth: 'weak', upload: false },
+        AUTH_REFRESH_TOKEN: { type: 'void', auth: 'none', upload: false },
+        AUTH_REQUEST_EMAIL_VERIFICATION_TOKEN: { type: 'void', auth: 'none', upload: false },
+        AUTH_REQUEST_NEW_PASSWORD: { type: 'void', auth: 'none', upload: false },
+        AUTH_SIGNUP: { type: 'json', auth: 'none', upload: false },
+        AUTH_SUBMIT_NEW_PASSWORD: { type: 'void', auth: 'none', upload: false },
+        AUTH_VERIFY_EMAIL: { type: 'json', auth: 'none', upload: false },
+        AUTH_WHOAMI: { type: 'json', auth: 'strong', upload: false },
+        AUTH_WHOAMI_GET: { type: 'json', auth: 'strong', upload: false },
+        CSRF_GET_TOKEN: { type: 'json', auth: 'none', upload: false },
+        EXAMPLE_PLUGIN__SOMETHING: { type: 'json', auth: 'none', upload: false },
+        IMAGE_FORMAT: { type: 'file', auth: 'strong', upload: true },
+        IMAGE_TRANSFORM: { type: 'file', auth: 'strong', upload: true },
+        SYSTEM_KILL: { type: 'void', auth: 'strong', upload: false },
+        SYSTEM_PING: { type: 'json', auth: 'none', upload: false },
+        SYSTEM_SEND_MAIL: { type: 'void', auth: 'strong', upload: false },
+        SYSTEM_STATUS_CHECK_GET: { type: 'json', auth: 'none', upload: false },
+        SYSTEM_STATUS_CHECK_POST: { type: 'json', auth: 'none', upload: false },
+        USERS_GET: { type: 'json', auth: 'none', upload: false },
+        // Plugins
+        TEST_PLUGIN__FILE: { type: 'file', auth: 'none', upload: false },
+        TEST_PLUGIN__FILE_POST: { type: 'file', auth: 'none', upload: false },
+        TEST_PLUGIN__FILE_POST_AUTH: { type: 'file', auth: 'strong', upload: false },
+        TEST_PLUGIN__JSON: { type: 'json', auth: 'none', upload: false },
+        TEST_PLUGIN__JSON_POST: { type: 'json', auth: 'none', upload: false },
+        TEST_PLUGIN__JSON_POST_AUTH: { type: 'json', auth: 'strong', upload: false },
+        TEST_PLUGIN__LIST: { type: 'list', auth: 'none', upload: false },
+        TEST_PLUGIN__LIST_POST: { type: 'list', auth: 'none', upload: false },
+        TEST_PLUGIN__LIST_POST_AUTH: { type: 'list', auth: 'strong', upload: false },
+        TEST_PLUGIN__VOID: { type: 'void', auth: 'none', upload: false },
+        TEST_PLUGIN__VOID_POST: { type: 'void', auth: 'none', upload: false },
+        TEST_PLUGIN__VOID_POST_AUTH: { type: 'void', auth: 'strong', upload: false },
+        DESIGN_EDITO_THUMBS_UPLOAD_TEMP: { type: 'json', auth: 'strong', upload: true },
+        DESIGN_EDITO_THUMBS_DOWNLOAD_TEMP: { type: 'file', auth: 'strong', upload: false },
+        DESIGN_EDITO_THUMBS_TEMPLATE_BOOK_GENERATE: { type: 'file', auth: 'strong', upload: false }
+    };
+}
+export { Requester };

package/agnostic/elo/index.d.ts

@@ -0,0 +1,23 @@
+/** Default K-factor used in Elo rating updates. Determines the maximum change in rating per game. */
+export declare const DEFAULT_K_FACTOR = 32;
+/** Default scale used in Elo probability calculation. Represents the rating difference that corresponds to ~90% win probability. */
+export declare const DEFAULT_SCALE = 400;
+/**
+ * Calculates the expected probability of player A winning against player B.
+ *
+ * @param {number} eloA - Elo rating of player A.
+ * @param {number} eloB - Elo rating of player B.
+ * @param {number} [scale=DEFAULT_SCALE] - Scale factor controlling sensitivity to rating differences.
+ * @returns {number} Probability that player A wins (between 0 and 1).
+ */
+export declare function getWinProbability(eloA: number, eloB: number, scale?: number): number;
+/**
+ * Updates a player's Elo rating based on the expected probability and actual outcome.
+ *
+ * @param {number} winProbability - Expected probability of winning (from getWinProbability).
+ * @param {number} actualOutcome - Actual result of the match (0 = loss, 0.5 = draw, 1 = win; can be fractional for weighted outcomes).
+ * @param {number} currentElo - Player's current Elo rating.
+ * @param {number} [kFactor=DEFAULT_K_FACTOR] - Maximum rating change per game.
+ * @returns {number} Updated Elo rating.
+ */
+export declare function updateRating(winProbability: number, actualOutcome: number, currentElo: number, kFactor?: number): number;

package/agnostic/elo/index.js

@@ -0,0 +1,28 @@
+/** Default K-factor used in Elo rating updates. Determines the maximum change in rating per game. */
+export const DEFAULT_K_FACTOR = 32;
+/** Default scale used in Elo probability calculation. Represents the rating difference that corresponds to ~90% win probability. */
+export const DEFAULT_SCALE = 400;
+/**
+ * Calculates the expected probability of player A winning against player B.
+ *
+ * @param {number} eloA - Elo rating of player A.
+ * @param {number} eloB - Elo rating of player B.
+ * @param {number} [scale=DEFAULT_SCALE] - Scale factor controlling sensitivity to rating differences.
+ * @returns {number} Probability that player A wins (between 0 and 1).
+ */
+export function getWinProbability(eloA, eloB, scale = DEFAULT_SCALE) {
+    const exponent = (eloB - eloA) / scale;
+    return 1 / (1 + Math.pow(10, exponent));
+}
+/**
+ * Updates a player's Elo rating based on the expected probability and actual outcome.
+ *
+ * @param {number} winProbability - Expected probability of winning (from getWinProbability).
+ * @param {number} actualOutcome - Actual result of the match (0 = loss, 0.5 = draw, 1 = win; can be fractional for weighted outcomes).
+ * @param {number} currentElo - Player's current Elo rating.
+ * @param {number} [kFactor=DEFAULT_K_FACTOR] - Maximum rating change per game.
+ * @returns {number} Updated Elo rating.
+ */
+export function updateRating(winProbability, actualOutcome, currentElo, kFactor = DEFAULT_K_FACTOR) {
+    return currentElo + kFactor * (actualOutcome - winProbability);
+}

package/agnostic/elo/index.test.js

@@ -0,0 +1,67 @@
+import { describe, it, expect } from 'vitest';
+import { DEFAULT_K_FACTOR, DEFAULT_SCALE, getWinProbability, updateRating } from './index.js';
+describe('getWinProbability', () => {
+    it('returns 0.5 for equal ratings', () => {
+        expect(getWinProbability(1500, 1500)).toBeCloseTo(0.5);
+    });
+    it('returns higher than 0.5 when first player is stronger', () => {
+        expect(getWinProbability(1600, 1400)).toBeGreaterThan(0.5);
+    });
+    it('returns lower than 0.5 when first player is weaker', () => {
+        expect(getWinProbability(1400, 1600)).toBeLessThan(0.5);
+    });
+    it('respects a custom scale', () => {
+        const customScale = 200;
+        const p1 = getWinProbability(1600, 1400, customScale);
+        const p2 = getWinProbability(1600, 1400, DEFAULT_SCALE);
+        expect(p1).toBeGreaterThan(p2); // smaller scale → bigger difference
+    });
+});
+describe('updateRating', () => {
+    it('does not change rating if actual equals expected', () => {
+        const current = 1500;
+        const expected = 0.5;
+        const actual = 0.5;
+        const newRating = updateRating(expected, actual, current);
+        expect(newRating).toBeCloseTo(current);
+    });
+    it('increases rating if actual > expected', () => {
+        const current = 1500;
+        const expected = 0.3;
+        const actual = 1;
+        const newRating = updateRating(expected, actual, current);
+        expect(newRating).toBeGreaterThan(current);
+    });
+    it('decreases rating if actual < expected', () => {
+        const current = 1500;
+        const expected = 0.7;
+        const actual = 0;
+        const newRating = updateRating(expected, actual, current);
+        expect(newRating).toBeLessThan(current);
+    });
+    it('accepts fractional actualOutcome (for margin of victory)', () => {
+        const current = 1500;
+        const expected = 0.4;
+        const actual = 0.8;
+        const newRating = updateRating(expected, actual, current);
+        expect(newRating).toBeGreaterThan(current);
+        expect(newRating).toBeLessThan(current + DEFAULT_K_FACTOR); // should not exceed max K
+    });
+    it('respects custom K-factor', () => {
+        const current = 1500;
+        const expected = 0.5;
+        const actual = 1;
+        const customK = 50;
+        const newRatingDefault = updateRating(expected, actual, current);
+        const newRatingCustom = updateRating(expected, actual, current, customK);
+        expect(newRatingCustom - current).toBeGreaterThan(newRatingDefault - current);
+    });
+});
+describe('CONSTANTS', () => {
+    it('DEFAULT_K_FACTOR is 32', () => {
+        expect(DEFAULT_K_FACTOR).toBe(32);
+    });
+    it('DEFAULT_SCALE is 400', () => {
+        expect(DEFAULT_SCALE).toBe(400);
+    });
+});

package/agnostic/index.d.ts

@@ -0,0 +1,5 @@
+export * as publisher from './@publisher/index.js'
+export * as elo from './elo/index.js'
+export * as poetry from './poetry/index.js'
+export * as scrapers from './scrapers/index.js'
+export * as weather from './weather/index.js'

package/agnostic/index.js

@@ -0,0 +1,5 @@
+export * as publisher from './@publisher/index.js'
+export * as elo from './elo/index.js'
+export * as poetry from './poetry/index.js'
+export * as scrapers from './scrapers/index.js'
+export * as weather from './weather/index.js'

package/agnostic/poetry/generate-rhymes/index.d.ts

@@ -0,0 +1 @@
+export {};

package/agnostic/poetry/generate-rhymes/index.js

@@ -0,0 +1,125 @@
+/* Linting is suspended on this file — dormant project, left as it was found. See
+   « Two files opted out of linting » in README.md before removing this. */
+/* eslint-disable
+  @typescript-eslint/no-unsafe-type-assertion,
+  @typescript-eslint/no-unused-vars,
+  no-console
+*/
+import { shuffle } from '@design-edito/tools/agnostic/arrays/shuffle/index.js';
+/* * * * * * * * * * * * * * * * *
+ *
+ * Rhyme Generator
+ *
+ * * * * * * * * * * * * * * * * */
+function getRandomSum(n) {
+    if (n <= 0 || !Number.isInteger(n))
+        throw new Error('n doit être un entier positif');
+    const result = [];
+    let remaining = n;
+    while (remaining > 0) {
+        const value = Math.floor((1 - (Math.random() * Math.random())) * remaining) + 1; // [1, remaining]
+        result.push(value);
+        remaining -= value;
+    }
+    return result;
+}
+const getWordsByFeet = (feet, wordsRecord) => Object
+    .entries(wordsRecord)
+    .filter(([, value]) => value === feet)
+    .map(([key]) => key);
+const getWords = (feet, wordsRecord, coeff) => {
+    const foundWordsThatLong = shuffle(getWordsByFeet(feet, wordsRecord))[0];
+    if (feet === 1) {
+        if (foundWordsThatLong === undefined)
+            throw new Error('need at least 1 word that is 1 foot long');
+        return [foundWordsThatLong];
+    }
+    if (foundWordsThatLong !== undefined
+        && Math.random() < coeff)
+        return [foundWordsThatLong];
+    let randomSubParts = [];
+    while (randomSubParts.length < 2) {
+        randomSubParts = getRandomSum(feet);
+    }
+    return randomSubParts.map(ft => getWords(ft, wordsRecord, coeff)).flat();
+};
+const flattenRhymeRecord = (rhymRec) => {
+    return Object.entries(rhymRec).reduce((acc, [rhyme, words]) => {
+        return { ...acc, ...words };
+    }, {});
+};
+const getRhyme = (suffix, feet, rhymeRecord, coeff) => {
+    const foundRhymeThatLong = shuffle(getWordsByFeet(feet, rhymeRecord[suffix] ?? {}))[0];
+    if (feet === 1) {
+        if (foundRhymeThatLong === undefined)
+            return [`${suffix} *`]; //throw new Error('need at least 1 word that is 1 foot long')
+        return [foundRhymeThatLong];
+    }
+    if (foundRhymeThatLong !== undefined
+        && Math.random() < coeff)
+        return [foundRhymeThatLong];
+    let randomSubParts = [];
+    while (randomSubParts.length < 2) {
+        randomSubParts = getRandomSum(feet);
+    }
+    return randomSubParts.map((ft, pos) => {
+        if (pos === randomSubParts.length - 1)
+            return getRhyme(suffix, ft, rhymeRecord, coeff);
+        return shuffle(getWords(ft, flattenRhymeRecord(rhymeRecord), coeff));
+    }).flat();
+};
+const getPoem = function (stanza, rhymeRecord, coeff) {
+    return stanza.map(({ length, rhyme }) => length === 0 ? '' : getRhyme(rhyme, length, rhymeRecord, coeff).join(' ')).join('\n');
+};
+/* * * * * * * * * * * * * * * * *
+ *
+ * TESTS - Rhyme Generator
+ *
+ * * * * * * * * * * * * * * * * */
+const rhymeRecord = {
+    '-a': {
+        'a': 1,
+    },
+    '-è': {
+        'eh': 1,
+    }
+};
+const _rhymeRecordTypecheck = rhymeRecord;
+const COEFF = .85;
+console.log(`
+
+  ${getPoem([{
+        length: 4,
+        rhyme: '-a'
+    }, {
+        length: 4,
+        rhyme: '-a'
+    }, {
+        length: 3,
+        rhyme: '-è'
+    }, {
+        length: 0
+    }, {
+        length: 2,
+        rhyme: '-a'
+    }, {
+        length: 0
+    }, {
+        length: 2,
+        rhyme: '-è'
+    }, {
+        length: 4,
+        rhyme: '-è'
+    }, {
+        length: 0
+    }, {
+        length: 4,
+        rhyme: '-a'
+    }, {
+        length: 3,
+        rhyme: '-è'
+    }, {
+        length: 1542,
+        rhyme: '-a'
+    }], rhymeRecord, COEFF)}
+`);

package/agnostic/poetry/index.d.ts

@@ -0,0 +1 @@
+export * as generateRhymes from './generate-rhymes/index.js'