@mxfb/tools 0.3.0 → 1.0.2

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'

package/agnostic/poetry/index.js

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

package/agnostic/scrapers/@meteociel/index.d.ts

@@ -0,0 +1,36 @@
+import { type CityName } from './locations/index.js';
+import type { WeatherForecast } from '../../weather/types.js';
+import type { ForecastMode } from './types.js';
+/**
+ * Builds the Meteociel forecast page URL for a given city and forecast mode.
+ *
+ * @param cityName - The city identifier used to resolve Meteociel location data.
+ * @param mode - The forecast mode to use when building the URL.
+ * @returns The fully qualified Meteociel URL for the requested city and mode.
+ * @throws If the provided forecast mode is not supported.
+ */
+export declare function getCityAndModeUrl(cityName: CityName, mode: ForecastMode): string;
+/**
+ * Fetches a remote HTML page and decodes it using ISO-8859-1 encoding.
+ *
+ * @param url - The URL of the page to fetch.
+ * @returns The decoded HTML content of the fetched page.
+ */
+export declare function fetchPage(url: string): Promise<string>;
+/**
+ * Retrieves and scrapes weather forecast data for a given city and forecast mode.
+ *
+ * @param cityName - The city for which to retrieve weather forecasts.
+ * @param mode - The forecast mode determining the scraping strategy.
+ * @returns An array of weather forecasts enriched with city location metadata.
+ * @throws If the forecast mode is unknown or unsupported.
+ */
+export declare function scrap(cityName: CityName, mode: ForecastMode): Promise<WeatherForecast[]>;
+/**
+ * Scrapes 3-day GFS weather simple forecasts from a Meteociel HTML page.
+ *
+ * @param pageContent - The raw HTML content of the Meteociel forecast page.
+ * @returns An array of weather forecasts parsed from the page content.
+ * @throws If required data such as issue time or geolocation cannot be extracted.
+ */
+export declare function scrapSimpleGfsPrevisions(pageContent: string): WeatherForecast[];

package/agnostic/scrapers/@meteociel/index.js

@@ -0,0 +1,248 @@
+import { JSDOM } from 'jsdom';
+import { citiesData } from './locations/index.js';
+/**
+ * Builds the Meteociel forecast page URL for a given city and forecast mode.
+ *
+ * @param cityName - The city identifier used to resolve Meteociel location data.
+ * @param mode - The forecast mode to use when building the URL.
+ * @returns The fully qualified Meteociel URL for the requested city and mode.
+ * @throws If the provided forecast mode is not supported.
+ */
+export function getCityAndModeUrl(cityName, mode) {
+    // `ForecastMode` has a single member today; this guard and the `default` branch of
+    // `scrap` are what will catch a second one.
+    /* eslint-disable-next-line @typescript-eslint/no-unnecessary-condition */
+    const modeUrlChunk = mode === 'simple-gfs' ? 'previsions' : null;
+    if (modeUrlChunk === null)
+        throw new Error('invalid mode');
+    return 'https://www.meteociel.fr/'
+        + `${modeUrlChunk}/`
+        + `${citiesData[cityName].id}/`
+        + `${citiesData[cityName].urlSuffix}.htm`;
+}
+/**
+ * Fetches a remote HTML page and decodes it using ISO-8859-1 encoding.
+ *
+ * @param url - The URL of the page to fetch.
+ * @returns The decoded HTML content of the fetched page.
+ */
+export async function fetchPage(url) {
+    const fetched = await fetch(url);
+    const buffer = await fetched.arrayBuffer();
+    const html = new TextDecoder('iso-8859-1').decode(buffer);
+    return html;
+}
+/**
+ * Retrieves and scrapes weather forecast data for a given city and forecast mode.
+ *
+ * @param cityName - The city for which to retrieve weather forecasts.
+ * @param mode - The forecast mode determining the scraping strategy.
+ * @returns An array of weather forecasts enriched with city location metadata.
+ * @throws If the forecast mode is unknown or unsupported.
+ */
+export async function scrap(cityName, mode) {
+    const url = getCityAndModeUrl(cityName, mode);
+    const fetched = await fetchPage(url);
+    switch (mode) {
+        /* eslint-disable-next-line @typescript-eslint/no-unnecessary-condition */
+        case 'simple-gfs': {
+            const scraped = scrapSimpleGfsPrevisions(fetched);
+            return scraped.map(i => ({
+                ...i,
+                location: {
+                    ...i.location,
+                    name: cityName
+                }
+            }));
+        }
+        /* eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check */
+        default: throw new Error('unknown-mode');
+    }
+}
+/**
+ * Scrapes 3-day GFS weather simple forecasts from a Meteociel HTML page.
+ *
+ * @param pageContent - The raw HTML content of the Meteociel forecast page.
+ * @returns An array of weather forecasts parsed from the page content.
+ * @throws If required data such as issue time or geolocation cannot be extracted.
+ */
+export function scrapSimpleGfsPrevisions(pageContent) {
+    const dom = new JSDOM(pageContent);
+    const { document } = dom.window;
+    // Storing collection time
+    const COLLECTED_ON = new Date();
+    // Extracting relevant DOM nodes
+    const h3Parent = Array
+        .from(document.querySelectorAll('h3'))
+        .find(n => n.textContent.includes('Prévisions météo à 3 jours'))
+        ?.parentElement;
+    const issueTimeNode = Array
+        .from(h3Parent?.childNodes ?? [])
+        .find(n => n.textContent?.includes('Réactualisé à') === true);
+    const dataTableNode = Array
+        .from(document.querySelectorAll('tbody'))
+        .find(n => {
+        const trChldCnt = n.querySelectorAll('tr').length;
+        return trChldCnt > 25 && trChldCnt < 35;
+    });
+    const forecastTableRows = Array
+        .from(dataTableNode?.querySelectorAll('tr') ?? [])
+        .slice(2);
+    const locationNode = Array.from(Array
+        .from(document.querySelectorAll('p'))
+        .find(n => n.textContent.includes('sont expérimentales et déterminées à partir des données brutes de GFS, un modèle numérique américain'))
+        ?.childNodes ?? []).find(n => n.textContent?.startsWith('Localisation de') === true);
+    // Extracting issue time
+    const issuedOnRaw = issueTimeNode?.textContent?.match(/\b([0-9]{1,2}):([0-5][0-9])\b/v)?.[0];
+    if (issuedOnRaw === undefined)
+        throw new Error('no-refresh-time-found');
+    // The regex above matched, so there are exactly two colon-separated groups.
+    /* eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion */
+    const [issuedOnH, issuedOnM] = issuedOnRaw.split(':');
+    const issuedOnYesteredayMaybe = new Date();
+    issuedOnYesteredayMaybe.setDate(new Date().getDate() - 1);
+    issuedOnYesteredayMaybe.setHours(parseInt(issuedOnH));
+    issuedOnYesteredayMaybe.setMinutes(parseInt(issuedOnM));
+    issuedOnYesteredayMaybe.setSeconds(0);
+    issuedOnYesteredayMaybe.setMilliseconds(0);
+    const issuedOnYesteredayMaybeNowDiff = Math.abs(new Date().getTime() - issuedOnYesteredayMaybe.getTime());
+    const issuedOnTodayMaybe = new Date();
+    issuedOnTodayMaybe.setHours(parseInt(issuedOnH));
+    issuedOnTodayMaybe.setMinutes(parseInt(issuedOnM));
+    issuedOnTodayMaybe.setSeconds(0);
+    issuedOnTodayMaybe.setMilliseconds(0);
+    const issuedOnTodayMaybeNowDiff = Math.abs(new Date().getTime() - issuedOnTodayMaybe.getTime());
+    const ISSUED_ON = issuedOnYesteredayMaybeNowDiff > issuedOnTodayMaybeNowDiff
+        ? issuedOnTodayMaybe
+        : issuedOnYesteredayMaybe;
+    // Extracting location
+    function parseLocation(input) {
+        const regex = /Latitude\s+([NS])\s+(\d+)°(\d+)'\s+\/\s+Longitude\s+([EW])\s+(\d+)°(\d+)'\s+\/\s+Altitude\s*:\s*(\d+)\s*m/v;
+        const match = input.match(regex);
+        if (match === null)
+            throw new Error('Format de coordonnées invalide');
+        const [, latDir, latDeg, latMin, lonDir, lonDeg, lonMin, altStr] = match;
+        let lat = Number(latDeg) + Number(latMin) / 60;
+        let lon = Number(lonDeg) + Number(lonMin) / 60;
+        if (latDir === 'S')
+            lat = -1 * lat;
+        if (lonDir === 'W')
+            lon = -1 * lon;
+        const alt = Number(altStr);
+        return {
+            latitudeDeg: lat,
+            longitudeDeg: lon,
+            elevationM: alt
+        };
+    }
+    let LOCATION;
+    try {
+        LOCATION = parseLocation(locationNode?.textContent ?? '');
+    }
+    catch (err) {
+        throw new Error('no-geolocation-found', { cause: err });
+    }
+    // Accessing data table rows
+    let currentDateLabel = null;
+    const currentHour = new Date();
+    currentHour.setMinutes(0);
+    currentHour.setSeconds(0);
+    currentHour.setMilliseconds(0);
+    const returned = forecastTableRows.map(row => {
+        const cells = Array.from(row.querySelectorAll('td'));
+        // Filter out irrelevant lines
+        if (cells.length < 10 || cells.length > 11)
+            return undefined;
+        // Extract cells
+        let dateCell;
+        const otherCells = [];
+        if (cells.length === 11) {
+            dateCell = cells[0];
+            otherCells.push(...cells.slice(1));
+        }
+        else {
+            otherCells.push(...cells);
+        }
+        // Extract current date
+        if (dateCell !== undefined) {
+            currentDateLabel = dateCell.textContent;
+        }
+        const [hourCell, tempCell, , windDirCell, windSpeedCell, gustSpeedCell, rainAmountCell, hygrometryCell, airPressureCell, weatherCell] = otherCells;
+        const hour = hourCell?.textContent ?? null;
+        const temp = tempCell?.textContent ?? null;
+        const windDir = windDirCell?.querySelector('img')?.getAttribute('title') ?? null;
+        const [, windDirAngle = null] = windDir?.split(' : ') ?? [];
+        const windSpeed = windSpeedCell?.textContent ?? null;
+        const gustSpeed = gustSpeedCell?.textContent ?? null;
+        const rainAmount = rainAmountCell?.textContent === '--' ? null : (rainAmountCell?.textContent) ?? null;
+        const hygrometry = hygrometryCell?.textContent ?? null;
+        const airPressure = airPressureCell?.textContent ?? null;
+        const weather = weatherCell?.querySelector('img')?.getAttribute('title') ?? null;
+        // Infer the actual date
+        const rawDay = currentDateLabel;
+        const foundDate = rawDay?.slice(3) ?? '0';
+        const pMonthFullDate = new Date(currentHour);
+        pMonthFullDate.setMonth(currentHour.getMonth() - 1);
+        pMonthFullDate.setDate(parseInt(foundDate));
+        pMonthFullDate.setHours(parseInt(hour ?? '00'));
+        const curMonthFullDate = new Date(currentHour);
+        curMonthFullDate.setDate(parseInt(foundDate));
+        curMonthFullDate.setHours(parseInt(hour ?? '00'));
+        const nMonthFullDate = new Date(currentHour);
+        nMonthFullDate.setMonth(currentHour.getMonth() + 1);
+        nMonthFullDate.setDate(parseInt(foundDate));
+        nMonthFullDate.setHours(parseInt(hour ?? '00'));
+        const eligibleDateTimesDiff = [
+            Math.abs(currentHour.getTime() - pMonthFullDate.getTime()),
+            Math.abs(currentHour.getTime() - curMonthFullDate.getTime()),
+            Math.abs(currentHour.getTime() - nMonthFullDate.getTime())
+        ];
+        const minDateDiff = Math.min(...eligibleDateTimesDiff);
+        const indexOfMinDateDiff = eligibleDateTimesDiff.indexOf(minDateDiff);
+        const date = indexOfMinDateDiff === 0
+            ? pMonthFullDate
+            : (indexOfMinDateDiff === 1
+                ? curMonthFullDate
+                : (indexOfMinDateDiff === 2
+                    ? nMonthFullDate
+                    : currentHour));
+        const validityTo = new Date(date);
+        validityTo.setHours(date.getHours() + 3);
+        const VALIDITY = {
+            from: date,
+            to: validityTo
+        };
+        // Convert scraped data to WeatherForecast compliant types
+        const TEMPERATURE = { tempC: parseFloat(temp?.replace(' °C', '') ?? '') };
+        const HUMIDITY = { relativePercent: parseFloat(hygrometry?.replace(' %', '') ?? '') };
+        const WIND = {
+            speedMs: parseFloat(windSpeed ?? ''),
+            directionDeg: parseFloat(windDirAngle?.replace(' °', '') ?? ''),
+            gustMs: parseFloat(gustSpeed ?? '')
+        };
+        const PRESSURE = { stationLevelHpa: parseFloat(airPressure?.replace(' hPa', '') ?? '') };
+        const SOURCE = {
+            provider: 'Météociel',
+            type: 'model',
+            model: 'GFS'
+        };
+        // Return
+        const returned = {
+            issuedOn: ISSUED_ON,
+            location: LOCATION,
+            validity: VALIDITY,
+            temperature: TEMPERATURE,
+            humidity: HUMIDITY,
+            wind: WIND,
+            pressure: PRESSURE,
+            precipitationMmh: parseFloat(rainAmount ?? ''),
+            metadata: {
+                source: SOURCE,
+                description: weather ?? 'unknown',
+                collectedOn: COLLECTED_ON
+            }
+        };
+        return returned;
+    }).filter(e => e !== undefined);
+    return returned;
+}

package/agnostic/scrapers/@meteociel/index.test.d.ts

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

package/agnostic/scrapers/@meteociel/index.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { getCityAndModeUrl, fetchPage, scrap, scrapSimpleGfsPrevisions } from './index.js';
+import { citiesData } from './locations/index.js';
+describe('scrapers/@meteociel/weather/getCityAndModeUrl', () => {
+    it('builds a valid Meteociel URL for a supported mode', () => {
+        const city = Object.keys(citiesData)[0];
+        const url = getCityAndModeUrl(city, 'simple-gfs');
+        expect(url).toContain('https://www.meteociel.fr/');
+        expect(url).toContain('previsions');
+    });
+    it('throws on unsupported mode', () => {
+        const city = Object.keys(citiesData)[0];
+        // eslint-disable-next-line  @typescript-eslint/no-unsafe-argument
+        expect(() => getCityAndModeUrl(city, 'unknown')).toThrow();
+    });
+});
+describe('scrapers/@meteociel/weather/fetchPage', () => {
+    const originalFetch = global.fetch;
+    beforeEach(() => {
+        global.fetch = vi.fn(async () => ({
+            arrayBuffer: async () => new TextEncoder().encode('<html>ok</html>').buffer
+        }));
+    });
+    afterEach(() => {
+        global.fetch = originalFetch;
+    });
+    it('fetches and decodes HTML content', async () => {
+        const html = await fetchPage('https://example.com');
+        expect(html).toContain('<html>');
+    });
+});
+describe('scrapers/@meteociel/weather/scrap', () => {
+    it('throws on unsupported mode', async () => {
+        const city = Object.keys((await import('./locations/index.js')).citiesData)[0];
+        // eslint-disable-next-line  @typescript-eslint/no-unsafe-argument
+        await expect(scrap(city, 'unknown')).rejects.toBeDefined();
+    });
+});
+describe('scrapers/@meteociel/weather/scrapSimpleGfsPrevisions', () => {
+    it('throws when page content is invalid', () => {
+        expect(() => scrapSimpleGfsPrevisions('<html></html>')).toThrow();
+    });
+});

package/agnostic/scrapers/@meteociel/locations/index.d.ts

@@ -0,0 +1,11 @@
+export declare const citiesData: {
+    paris11: {
+        readonly id: 27827;
+        readonly urlSuffix: "paris_11eme_arrondissement";
+    };
+};
+export type CityName = keyof typeof citiesData;
+export type CityData = {
+    id: number;
+    urlSuffix: string;
+};

package/agnostic/scrapers/@meteociel/locations/index.js

@@ -0,0 +1,10 @@
+export const citiesData = {
+    // Paris 11e
+    'paris11': {
+        id: 27827,
+        urlSuffix: 'paris_11eme_arrondissement'
+    }
+};
+// Typecheck
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const _citiesDataTypecheck = citiesData;

package/agnostic/scrapers/@meteociel/types.d.ts

@@ -0,0 +1 @@
+export type ForecastMode = 'simple-gfs';

package/agnostic/scrapers/@meteociel/types.js

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

package/agnostic/scrapers/@tumblr/blogs/delabienbonnemusique/index.d.ts

@@ -0,0 +1,22 @@
+import type { TumblrBlogParser } from '../../types.js';
+/**
+ * Reads the theme `delabienbonnemusique.tumblr.com` has been frozen on since 2019.
+ *
+ * Every post is one track: a line of text in `.copy`, an embed in `.media` when the video
+ * still exists, and sometimes a `.copy.source` link. That line is kept whole and never
+ * taken apart — fifteen years of posts were not written to one format, and an artist
+ * guessed from a dash is worse than the line itself. Class names are what this reads,
+ * which is what a per-blog parser is for; the generic pass is the one that may not rely on
+ * them.
+ *
+ * What the years make fragile is the source: a YouTube or Dailymotion embed that may well
+ * be dead by now, a Spotify link, a Grooveshark one on the oldest posts. Every URL found
+ * in the embed or the body is kept, in the order it appeared, plus the embed's own title —
+ * which on a deleted video is the last trace of what it was.
+ *
+ * The date is the only one this blog has: the theme writes it in the `title` of its
+ * `.date` link, and the sitemap's `lastmod` is a 2023 bulk re-touch that says nothing
+ * about publication. It carries no timezone, so it is read as UTC and the label itself is
+ * kept in `detail.publishedLabel` for whoever needs to argue about the hour.
+ */
+export declare const parser: TumblrBlogParser;

package/agnostic/scrapers/@tumblr/blogs/delabienbonnemusique/index.js

@@ -0,0 +1,124 @@
+const MONTH_INDEXES_BY_FRENCH_NAME = new Map([
+    ['janvier', 0],
+    ['février', 1],
+    ['mars', 2],
+    ['avril', 3],
+    ['mai', 4],
+    ['juin', 5],
+    ['juillet', 6],
+    ['août', 7],
+    ['septembre', 8],
+    ['octobre', 9],
+    ['novembre', 10],
+    ['décembre', 11]
+]);
+// `Jeu. janvier 31, 2019 @ 5:39 pm` — the weekday is dropped, it states nothing the rest
+// does not.
+const DATE_LABEL_PATTERN = /^\p{L}+\.?\s+(\p{L}+)\s+(\d{1,2}),\s*(\d{4})\s*@\s*(\d{1,2}):(\d{2})\s*(am|pm)$/iv;
+const POST_TYPE_CLASS_PREFIX = 'type-';
+// Where a source can sit: the embed, or a link in the body. Everything else a post holds
+// is the theme's own — share buttons, the permalink, the short link.
+const SOURCE_AREA_SELECTOR = '.media, .copy';
+/**
+ * Reads the theme `delabienbonnemusique.tumblr.com` has been frozen on since 2019.
+ *
+ * Every post is one track: a line of text in `.copy`, an embed in `.media` when the video
+ * still exists, and sometimes a `.copy.source` link. That line is kept whole and never
+ * taken apart — fifteen years of posts were not written to one format, and an artist
+ * guessed from a dash is worse than the line itself. Class names are what this reads,
+ * which is what a per-blog parser is for; the generic pass is the one that may not rely on
+ * them.
+ *
+ * What the years make fragile is the source: a YouTube or Dailymotion embed that may well
+ * be dead by now, a Spotify link, a Grooveshark one on the oldest posts. Every URL found
+ * in the embed or the body is kept, in the order it appeared, plus the embed's own title —
+ * which on a deleted video is the last trace of what it was.
+ *
+ * The date is the only one this blog has: the theme writes it in the `title` of its
+ * `.date` link, and the sitemap's `lastmod` is a 2023 bulk re-touch that says nothing
+ * about publication. It carries no timezone, so it is read as UTC and the label itself is
+ * kept in `detail.publishedLabel` for whoever needs to argue about the hour.
+ */
+export const parser = {
+    parsePostDom: postElement => {
+        const copyElement = postElement.querySelector('.copy:not(.source)');
+        const publishedLabel = readDateLabel(postElement);
+        const iframe = postElement.querySelector('.media iframe');
+        const sourceUrls = readSourceUrls(postElement);
+        const detail = {
+            postType: readPostType(postElement),
+            publishedLabel,
+            sourceUrl: sourceUrls[0] ?? null,
+            sourceUrls,
+            embedTitle: iframe?.getAttribute('title') ?? null
+        };
+        const parsed = {
+            detail,
+            title: toTextOrNull(copyElement?.textContent ?? null),
+            contentHtml: copyElement?.innerHTML.trim() ?? null,
+            publishedOn: toDateOrNull(publishedLabel),
+            media: readMedia(iframe)
+        };
+        return parsed;
+    }
+};
+function toTextOrNull(raw) {
+    if (raw === null)
+        return null;
+    const normalized = raw.replace(/\s+/gv, ' ').trim();
+    return normalized === '' ? null : normalized;
+}
+function readSourceUrls(postElement) {
+    const urls = [];
+    for (const area of postElement.querySelectorAll(SOURCE_AREA_SELECTOR)) {
+        for (const node of area.querySelectorAll('iframe[src], a[href], embed[src]')) {
+            const url = node.getAttribute('src') ?? node.getAttribute('href');
+            if (url === null || url === '' || urls.includes(url))
+                continue;
+            urls.push(url);
+        }
+    }
+    return urls;
+}
+function readDateLabel(postElement) {
+    return toTextOrNull(postElement.querySelector('.date a')?.getAttribute('title') ?? null);
+}
+function readPostType(postElement) {
+    for (const className of Array.from(postElement.classList)) {
+        if (className.startsWith(POST_TYPE_CLASS_PREFIX)) {
+            return className.slice(POST_TYPE_CLASS_PREFIX.length);
+        }
+    }
+    return null;
+}
+function toDateOrNull(publishedLabel) {
+    if (publishedLabel === null)
+        return null;
+    const parts = DATE_LABEL_PATTERN.exec(publishedLabel);
+    if (parts === null)
+        return null;
+    const [, monthName, day, year, hour, minute, meridiem] = parts;
+    const monthIndex = MONTH_INDEXES_BY_FRENCH_NAME.get(monthName?.toLowerCase() ?? '');
+    if (monthIndex === undefined)
+        return null;
+    const hours = Number(hour) % 12 + (meridiem?.toLowerCase() === 'pm' ? 12 : 0);
+    return new Date(Date.UTC(Number(year), monthIndex, Number(day), hours, Number(minute)));
+}
+function readMedia(iframe) {
+    const url = iframe?.getAttribute('src') ?? null;
+    if (url === null)
+        return [];
+    return [{
+            kind: 'iframe',
+            url,
+            widthPx: toIntegerOrNull(iframe?.getAttribute('width') ?? null),
+            heightPx: toIntegerOrNull(iframe?.getAttribute('height') ?? null),
+            alternativeText: iframe?.getAttribute('title') ?? null
+        }];
+}
+function toIntegerOrNull(raw) {
+    if (raw === null)
+        return null;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isNaN(parsed) ? null : parsed;
+}

package/agnostic/scrapers/@tumblr/blogs/delabienbonnemusique/index.test.d.ts

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