@mxfb/tools 0.3.0 → 1.0.2

package/agnostic/scrapers/@tumblr/utils.js

@@ -0,0 +1,407 @@
+const TUMBLR_HOSTNAME_SUFFIX = '.tumblr.com';
+const TUMBLR_CANONICAL_HOSTNAMES = ['www.tumblr.com', 'tumblr.com'];
+const PERMALINK_PATHNAME_PATTERN = /^\/post\/(\d+)(?:\/|$)/v;
+const INDEX_PAGE_PATHNAME_PATTERN = /^\/page\/(\d+)(?:\/|$)/v;
+const ARCHIVE_PATHNAME_PATTERN = /^\/archive(?:\/|$)/v;
+const TAGGED_PATHNAME_PATTERN = /^\/tagged\//v;
+// A post block never reaches across one of these, so they stop the walk up the tree on a
+// permalink page, where no sibling post is there to stop it.
+const PAGE_LANDMARK_SELECTOR = 'nav, header, footer, aside';
+export function toIntegerOrNull(raw) {
+    if (raw === null)
+        return null;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isNaN(parsed) ? null : parsed;
+}
+export function readSitemapChildUrls(document) {
+    const urls = [];
+    for (const entry of Array.from(document.getElementsByTagName('sitemap'))) {
+        const url = readFirstChildText(entry, 'loc');
+        if (url !== null)
+            urls.push(url);
+    }
+    return urls;
+}
+export function readSitemapLocations(document) {
+    const locations = [];
+    for (const entry of Array.from(document.getElementsByTagName('url'))) {
+        const url = readFirstChildText(entry, 'loc');
+        if (url === null)
+            continue;
+        locations.push({
+            url,
+            lastModifiedOn: toDateOrNull(readFirstChildText(entry, 'lastmod'))
+        });
+    }
+    return locations;
+}
+export function toOrigin(url) {
+    if (url === null)
+        return null;
+    try {
+        return new URL(url).origin;
+    }
+    catch {
+        return null;
+    }
+}
+export function readMetaProperty(document, property) {
+    return readAttribute(document, `meta[property="${property}"]`, 'content');
+}
+export function extractCanonicalUrl(document) {
+    return readLinkHref(document, 'canonical')
+        ?? readMetaProperty(document, 'og:url');
+}
+export function extractPageKind(pageUrl) {
+    const pathname = toPathname(pageUrl);
+    if (pathname === null)
+        return 'unknown';
+    if (PERMALINK_PATHNAME_PATTERN.test(pathname))
+        return 'permalink';
+    if (ARCHIVE_PATHNAME_PATTERN.test(pathname))
+        return 'archive';
+    // Kept as a pattern to stay symmetric with the three above.
+    /* eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with */
+    if (TAGGED_PATHNAME_PATTERN.test(pathname))
+        return 'tagged';
+    if (INDEX_PAGE_PATHNAME_PATTERN.test(pathname))
+        return 'index';
+    if (pathname === '/')
+        return 'index';
+    return 'custom';
+}
+export function extractBlog(document, pageUrl, canonicalUrl, pageKind) {
+    const baseUrl = toOrigin(pageUrl);
+    const iconHref = readLinkHref(document, 'apple-touch-icon')
+        ?? readLinkHref(document, 'icon');
+    return {
+        name: extractBlogName(pageUrl, canonicalUrl),
+        title: readMetaProperty(document, 'og:site_name')
+            ?? toTextOrNull(document.querySelector('title')?.textContent ?? null),
+        description: extractBlogDescription(document, pageKind),
+        baseUrl,
+        avatarUrl: toAbsoluteUrl(iconHref, baseUrl),
+        navLinks: extractNavLinks(document, baseUrl)
+    };
+}
+export function extractPostFromPermalinkPage(document, pageUrl) {
+    const id = extractPostIdFromUrl(pageUrl);
+    const postIdByAnchor = indexPostAnchors(document, toOrigin(pageUrl));
+    return {
+        ...createIdentifiedPost(id, pageUrl),
+        type: extractPostType(readMetaProperty(document, 'og:type')),
+        publishedOn: toDateOrNull(readMetaProperty(document, 'article:published_time')),
+        title: readMetaProperty(document, 'og:title'),
+        tags: readEveryMetaProperty(document, 'article:tag'),
+        media: extractMedia(document),
+        ...readRawHtml(findPostElement(document, id, postIdByAnchor), 'permalink')
+    };
+}
+export function extractPostsFromListingPage(document, baseUrl) {
+    const postIdByAnchor = indexPostAnchors(document, baseUrl);
+    const postsById = new Map();
+    for (const [anchor, id] of postIdByAnchor) {
+        if (postsById.has(id))
+            continue;
+        const url = toAbsoluteUrl(anchor.getAttribute('href'), baseUrl);
+        postsById.set(id, {
+            ...createIdentifiedPost(id, url),
+            ...readRawHtml(findPostElement(document, id, postIdByAnchor), 'listing')
+        });
+    }
+    return Array.from(postsById.values());
+}
+export function extractPagination(document, pageUrl, baseUrl) {
+    const currentPageNumber = extractCurrentPageNumber(pageUrl);
+    const pageUrlsByNumber = collectPageUrlsByNumber(document, baseUrl);
+    const siblingPageUrl = (offset) => {
+        if (currentPageNumber === null)
+            return null;
+        return pageUrlsByNumber.get(currentPageNumber + offset) ?? null;
+    };
+    return {
+        currentPageNumber,
+        nextPageUrl: toAbsoluteUrl(readLinkHref(document, 'next'), baseUrl) ?? siblingPageUrl(1),
+        previousPageUrl: toAbsoluteUrl(readLinkHref(document, 'prev'), baseUrl) ?? siblingPageUrl(-1)
+    };
+}
+function readFirstChildText(element, tagName) {
+    return toTextOrNull(element.getElementsByTagName(tagName)[0]?.textContent ?? null);
+}
+function normalizeWhitespace(raw) {
+    return raw.replace(/\s+/gv, ' ').trim();
+}
+function toTextOrNull(raw) {
+    if (raw === null)
+        return null;
+    const normalized = normalizeWhitespace(raw);
+    return normalized === '' ? null : normalized;
+}
+function toDateOrNull(raw) {
+    if (raw === null)
+        return null;
+    const parsed = new Date(raw);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function toAbsoluteUrl(href, baseUrl) {
+    if (href === null)
+        return null;
+    try {
+        return new URL(href, baseUrl ?? undefined).href;
+    }
+    catch {
+        return null;
+    }
+}
+function toPathname(url) {
+    if (url === null)
+        return null;
+    try {
+        return new URL(url).pathname;
+    }
+    catch {
+        return null;
+    }
+}
+function sharesOrigin(url, baseUrl) {
+    if (baseUrl === null)
+        return true;
+    return toOrigin(url) === toOrigin(baseUrl);
+}
+function readAttribute(document, selector, attributeName) {
+    return toTextOrNull(document.querySelector(selector)?.getAttribute(attributeName) ?? null);
+}
+function readMetaName(document, name) {
+    return readAttribute(document, `meta[name="${name}"]`, 'content');
+}
+function readLinkHref(document, relation) {
+    return readAttribute(document, `link[rel="${relation}"]`, 'href');
+}
+function readEveryMetaProperty(document, property) {
+    return Array
+        .from(document.querySelectorAll(`meta[property="${property}"]`))
+        .map(element => toTextOrNull(element.getAttribute('content')))
+        .filter((content) => content !== null);
+}
+function extractBlogName(pageUrl, canonicalUrl) {
+    return readBlogNameFromCanonicalUrl(canonicalUrl)
+        ?? readBlogNameFromHostname(pageUrl);
+}
+function readBlogNameFromCanonicalUrl(canonicalUrl) {
+    if (canonicalUrl === null)
+        return null;
+    let url;
+    try {
+        url = new URL(canonicalUrl);
+    }
+    catch {
+        return null;
+    }
+    if (!TUMBLR_CANONICAL_HOSTNAMES.includes(url.hostname))
+        return null;
+    const segments = url.pathname.split('/').filter(segment => segment !== '');
+    return segments[0] ?? null;
+}
+function readBlogNameFromHostname(pageUrl) {
+    let hostname;
+    try {
+        hostname = new URL(pageUrl).hostname;
+    }
+    catch {
+        return null;
+    }
+    if (!hostname.endsWith(TUMBLR_HOSTNAME_SUFFIX))
+        return null;
+    const name = hostname.slice(0, -TUMBLR_HOSTNAME_SUFFIX.length);
+    if (name === '' || name === 'www' || name.includes('.'))
+        return null;
+    return name;
+}
+function extractBlogDescription(document, pageKind) {
+    if (pageKind === 'permalink')
+        return null;
+    return readMetaName(document, 'description')
+        ?? readMetaProperty(document, 'og:description');
+}
+function extractNavLinks(document, baseUrl) {
+    const navLinks = [];
+    const seenUrls = new Set();
+    for (const anchor of document.querySelectorAll('nav a[href], header a[href]')) {
+        const url = toAbsoluteUrl(anchor.getAttribute('href'), baseUrl);
+        const label = toTextOrNull(anchor.textContent);
+        if (url === null || label === null)
+            continue;
+        if (!sharesOrigin(url, baseUrl) || seenUrls.has(url))
+            continue;
+        seenUrls.add(url);
+        navLinks.push({ label, url });
+    }
+    return navLinks;
+}
+function extractPostIdFromUrl(url) {
+    const pathname = toPathname(url);
+    if (pathname === null)
+        return null;
+    return PERMALINK_PATHNAME_PATTERN.exec(pathname)?.[1] ?? null;
+}
+function extractPageNumberFromUrl(url) {
+    const pathname = toPathname(url);
+    if (pathname === null)
+        return null;
+    return toIntegerOrNull(INDEX_PAGE_PATHNAME_PATTERN.exec(pathname)?.[1] ?? null);
+}
+function extractPostType(openGraphType) {
+    if (openGraphType === null)
+        return 'unknown';
+    if (openGraphType.startsWith('video'))
+        return 'video';
+    if (openGraphType.startsWith('music'))
+        return 'audio';
+    return 'unknown';
+}
+function extractMedia(document) {
+    const media = [];
+    const imageUrl = readMetaProperty(document, 'og:image');
+    if (imageUrl !== null) {
+        media.push({
+            kind: 'image',
+            url: imageUrl,
+            widthPx: toIntegerOrNull(readMetaProperty(document, 'og:image:width')),
+            heightPx: toIntegerOrNull(readMetaProperty(document, 'og:image:height')),
+            alternativeText: readMetaProperty(document, 'og:image:alt')
+        });
+    }
+    const videoUrl = readMetaProperty(document, 'og:video');
+    if (videoUrl !== null) {
+        media.push({
+            kind: 'video',
+            url: videoUrl,
+            widthPx: toIntegerOrNull(readMetaProperty(document, 'og:video:width')),
+            heightPx: toIntegerOrNull(readMetaProperty(document, 'og:video:height')),
+            alternativeText: null
+        });
+    }
+    const audioUrl = readMetaProperty(document, 'og:audio');
+    if (audioUrl !== null) {
+        media.push({
+            kind: 'audio',
+            url: audioUrl,
+            widthPx: null,
+            heightPx: null,
+            alternativeText: null
+        });
+    }
+    return media;
+}
+function indexPostAnchors(document, baseUrl) {
+    const postIdByAnchor = new Map();
+    for (const anchor of document.querySelectorAll('a[href]')) {
+        const url = toAbsoluteUrl(anchor.getAttribute('href'), baseUrl);
+        if (url === null || !sharesOrigin(url, baseUrl))
+            continue;
+        const id = extractPostIdFromUrl(url);
+        if (id === null)
+            continue;
+        postIdByAnchor.set(anchor, id);
+    }
+    return postIdByAnchor;
+}
+function findPostElement(document, postId, postIdByAnchor) {
+    if (postId === null)
+        return null;
+    const blocks = [];
+    for (const [anchor, id] of postIdByAnchor) {
+        if (id !== postId)
+            continue;
+        const block = climbToPostBlock(anchor, postId, postIdByAnchor);
+        if (block !== null && !blocks.includes(block))
+            blocks.push(block);
+    }
+    if (blocks.length === 0)
+        return document.querySelector('article');
+    const namedBlocks = blocks.filter(block => namesPost(block, postId));
+    return widestElement(namedBlocks.length > 0 ? namedBlocks : blocks);
+}
+function climbToPostBlock(anchor, postId, postIdByAnchor) {
+    let candidate = anchor;
+    let widestBlock = null;
+    let nearestNamedBlock = null;
+    while (holdsOnlyThisPost(candidate, postId, postIdByAnchor)) {
+        widestBlock = candidate;
+        if (nearestNamedBlock === null && namesPost(candidate, postId))
+            nearestNamedBlock = candidate;
+        const parent = candidate.parentElement;
+        if (parent === null || parent.tagName === 'BODY' || parent.tagName === 'HTML')
+            break;
+        candidate = parent;
+    }
+    return nearestNamedBlock ?? widestBlock;
+}
+function widestElement(elements) {
+    let widest = null;
+    for (const element of elements) {
+        if (widest === null || element.outerHTML.length > widest.outerHTML.length)
+            widest = element;
+    }
+    return widest;
+}
+function holdsOnlyThisPost(element, postId, postIdByAnchor) {
+    if (element.matches(PAGE_LANDMARK_SELECTOR))
+        return false;
+    if (element.querySelector(PAGE_LANDMARK_SELECTOR) !== null)
+        return false;
+    for (const anchor of element.querySelectorAll('a[href]')) {
+        const id = postIdByAnchor.get(anchor);
+        if (id !== undefined && id !== postId)
+            return false;
+    }
+    return true;
+}
+function namesPost(element, postId) {
+    return element.tagName === 'ARTICLE' || element.id.includes(postId);
+}
+function readRawHtml(postElement, source) {
+    if (postElement === null)
+        return { rawHtml: null, rawHtmlSource: null };
+    return { rawHtml: postElement.outerHTML, rawHtmlSource: source };
+}
+function createIdentifiedPost(id, url) {
+    return {
+        id,
+        url,
+        type: 'unknown',
+        publishedOn: null,
+        title: null,
+        contentHtml: null,
+        rawHtml: null,
+        rawHtmlSource: null,
+        detail: null,
+        tags: [],
+        media: [],
+        notesCount: null,
+        reblogOfUrl: null,
+        lastModifiedOn: null
+    };
+}
+function collectPageUrlsByNumber(document, baseUrl) {
+    const pageUrlsByNumber = new Map();
+    for (const anchor of document.querySelectorAll('a[href]')) {
+        const url = toAbsoluteUrl(anchor.getAttribute('href'), baseUrl);
+        if (url === null || !sharesOrigin(url, baseUrl))
+            continue;
+        const pageNumber = extractPageNumberFromUrl(url);
+        if (pageNumber === null || pageUrlsByNumber.has(pageNumber))
+            continue;
+        pageUrlsByNumber.set(pageNumber, url);
+    }
+    return pageUrlsByNumber;
+}
+function extractCurrentPageNumber(pageUrl) {
+    const pathname = toPathname(pageUrl);
+    if (pathname === null)
+        return null;
+    const declaredPageNumber = extractPageNumberFromUrl(pageUrl);
+    if (declaredPageNumber !== null)
+        return declaredPageNumber;
+    return pathname === '/' ? 1 : null;
+}

package/agnostic/scrapers/index.d.ts

@@ -0,0 +1,2 @@
+export * as meteociel from './@meteociel/index.js'
+export * as tumblr from './@tumblr/index.js'

package/agnostic/scrapers/index.js

@@ -0,0 +1,2 @@
+export * as meteociel from './@meteociel/index.js'
+export * as tumblr from './@tumblr/index.js'

package/agnostic/weather/index.d.ts

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

package/agnostic/weather/index.js

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

package/agnostic/weather/types.d.ts

@@ -0,0 +1,181 @@
+/**
+ * Core weather data types for archiving and exchanging meteorological information.
+ *
+ * The structures are inspired by WMO (World Meteorological Organization) guidance
+ * and CF Conventions. Units are encoded explicitly in property names to avoid
+ * ambiguity and to make transformations between systems easier and safer.
+ */
+/** Geographic location following the WGS84 reference system. */
+export type GeoLocation = {
+    /** Latitude in decimal degrees (-90 to +90). */ latitudeDeg: number;
+    /** Longitude in decimal degrees (-180 to +180). */ longitudeDeg: number;
+    /** Elevation in meters above mean sea level. */ elevationM?: number;
+    /** Human-readable place name (city, station, etc.). */ name?: string;
+    /** Country code in ISO 3166-1 alpha-2 format (e.g. "FR", "US"). */ countryCode31661a2?: string;
+    /** Administrative region, state, or province name. */ region?: string;
+};
+/** Source of observed meteorological data. */
+export type ObservationDataSource = {
+    /** Data provider name */ provider: string;
+    /** High-level type of source */ type: 'satellite' | 'radar' | 'station' | 'derived' | 'manual' | 'other';
+    /** Identifier of the observing station or sensor when applicable. */ stationId?: string;
+    /** URL pointing to the data source or documentation. */ url?: string;
+    /** Data license or usage terms (short free-text). */ license?: string;
+};
+/** Source of forecast data. Describes both deterministic and ensemble-based forecast systems. */
+export type ForecastDataSource = {
+    /** Provider or operator name */ provider: string;
+    /** Type of forecast product. */ type: 'model' | 'ensemble' | 'derived' | 'other';
+    /** Model name or product identifier (e.g. "GFS", "AROME"). */ model?: string;
+    /** Model version, configuration, or cycle identifier. */ modelVersion?: string;
+    /** Model initialization date */ runTime?: Date;
+    /** Ensemble member identifier for probabilistic forecasts. */ ensembleMember?: string;
+    /** URL pointing to model documentation or the data endpoint. */ url?: string;
+    /** Data license or usage terms for the forecast. */ license?: string;
+};
+/** Temperature-related fields. */
+export type Temperature = {
+    /** Air temperature in degrees Celsius. */ tempC: number;
+    /** Feels-like temperature in °C (wind chill or heat index depending on conditions). */ feelsLikeC?: number;
+    /** Dew point temperature in °C. */ dewPointC?: number;
+    /** Minimum temperature over the period in °C. */ minC?: number;
+    /** Maximum temperature over the period in °C. */ maxC?: number;
+};
+/** Humidity parameters. */
+export type Humidity = {
+    /** Relative humidity in percent (0–100). */ relativePercent: number;
+    /** Absolute humidity in grams per cubic meter. */ absoluteGm3?: number;
+};
+/** Wind according to common WMO conventions. */
+export type Wind = {
+    /** Mean wind speed in meters per second. */ speedMs: number;
+    /** Wind direction in degrees (0–360, where 0/360 = North, 90 = East). */ directionDeg: number;
+    /** Maximum gust speed in meters per second over the period. */ gustMs?: number;
+};
+/** Canonical list of WMO cloud genera. */
+export type CloudType = 'cirrus' | 'cirrocumulus' | 'cirrostratus' | 'altocumulus' | 'altostratus' | 'nimbostratus' | 'stratocumulus' | 'stratus' | 'cumulus' | 'cumulonimbus';
+/** Cloud cover information following common WMO recommendations. */
+export type CloudCover = {
+    /** Total cloud cover in percent (0–100). */ totalPercent: number;
+    /** Low-level cloud fraction in percent (0–100). */ lowPercent?: number;
+    /** Mid-level cloud fraction in percent (0–100). */ middlePercent?: number;
+    /** High-level cloud fraction in percent (0–100). */ highPercent?: number;
+    /** Cloud base height in meters above ground level. */ cloudBaseHeightM?: number;
+    /** Dominant cloud genus when it can be identified. */ dominantGenre?: CloudType;
+};
+/** Canonical list of atmospheric phenomena based on WMO classification. */
+export type AtmosphericPhenomenon = 'rain' | 'drizzle' | 'freezing-rain' | 'snow' | 'snow-grains' | 'ice-pellets' | 'hail' | 'fog' | 'mist' | 'haze' | 'smoke' | 'dust' | 'sand' | 'volcanic-ash' | 'thunderstorm' | 'squall' | 'funnel-cloud';
+/** Single atmospheric phenomenon, observed or forecast. */
+export type WeatherPhenomenon = {
+    /** Phenomenon type according to the WMO-inspired list. */ phenomenon: AtmosphericPhenomenon;
+    /** Qualitative intensity: "+" for heavy, "-" for light, or null for normal. */ intensity: '+' | '-' | null;
+    /** Optional free-text remark describing special characteristics. */ remark?: string;
+};
+/** Atmospheric pressure. */
+export type Pressure = {
+    /** Sea-level pressure in hectopascals (millibars). */ seaLevelHpa?: number;
+    /** Station-level pressure in hectopascals at the observing elevation. */ stationLevelHpa: number;
+};
+/** Visibility metrics. */
+export type Visibility = {
+    /** Horizontal visibility in meters. */ horizontalM?: number;
+    /** Vertical visibility in meters (e.g. ceiling height). */ verticalM?: number;
+};
+/** Solar radiation and UV information. */
+export type Solar = {
+    /** Global solar radiation in watts per square meter. */ radiationWm2?: number;
+    /** Dimensionless UV index, typically between 0 and ~12. */ uvIndex?: number;
+};
+/** Air quality indicators. */
+export type AirQuality = {
+    /** Fine particulate matter PM2.5 in micrograms per cubic meter. */ pm25Ugm3?: number;
+    /** Particulate matter PM10 in micrograms per cubic meter. */ pm10Ugm3?: number;
+    /** Ozone (O₃) concentration in micrograms per cubic meter. */ o3Ugm3?: number;
+    /** Nitrogen dioxide (NO₂) concentration in micrograms per cubic meter. */ no2Ugm3?: number;
+    /** Sulfur dioxide (SO₂) concentration in micrograms per cubic meter. */ so2Ugm3?: number;
+    /** Carbon monoxide (CO) concentration in micrograms per cubic meter. */ coUgm3?: number;
+};
+/** Quality metadata attached to an observation or measurement. */
+export type ObservationQualityMetadata = {
+    /** Status of the data, typically resulting from QC checks or post-processing. */ status?: 'verified' | 'unverified' | 'estimated' | 'interpolated' | 'suspect';
+    /** Free-text notes or comments about the data quality. */ notes?: string;
+};
+/** Validity period of a forecast or alert. */
+export type ValidityPeriod = {
+    /** Start of validity */ from: Date;
+    /** End of validity */ to: Date;
+};
+/** Weather alert or warning issued by an authority or provider. */
+export type WeatherAlert = {
+    /** Alert type or category (e.g. "wind", "flood", "heat"). */ type: string;
+    /** Severity level as a normalized qualitative scale. */ severity: 'minor' | 'moderate' | 'severe' | 'extreme';
+    /** Human-readable description of the alert and its expected impacts. */ description?: string;
+    /** Validity period of a forecast or alert. */ validity?: ValidityPeriod;
+};
+/** Probabilistic forecast data for a single parameter. */
+export type ProbabilisticData = {
+    /** Confidence level for the forecast (0–100%). */ confidencePercent?: number;
+    /** Temperature 10th percentile in °C (optimistic or cooler scenario). */ tempP10C?: number;
+    /** Temperature 90th percentile in °C (pessimistic or warmer scenario). */ tempP90C?: number;
+};
+/**
+ * Core weather data structure containing essential meteorological measurements.
+ *
+ * This type represents the fundamental weather parameters that can be used
+ * for both observations and forecasts. It follows WMO conventions and uses
+ * explicit unit encoding in property names to ensure clarity and type safety.
+ *
+ * All core measurements are required, while some extended parameters
+ * (visibility, solar, air quality, alerts) are optional.
+ *
+ * @see WeatherObservation - For observation-specific data with location and time
+ * @see WeatherForecast - For forecast-specific data with validity periods
+ */
+export type WeatherDataCore = {
+    /** Temperature-related measurements at the observation time. */ temperature: Temperature;
+    /** Humidity-related measurements at the observation time. */ humidity: Humidity;
+    /** Wind conditions at the observation time. */ wind: Wind;
+    /** Instantaneous precipitation rates at the observation time. */ precipitationMmh: number;
+    /** Atmospheric pressure at or reduced to station/sea level. */ pressure: Pressure;
+    /** List of significant weather phenomena observed. */ phenomena?: WeatherPhenomenon[];
+    /** Cloud cover information at the observation time. */ clouds?: CloudCover;
+    /** Visibility metrics at the observation time. */ visibility?: Visibility;
+    /** Solar radiation and UV information at the observation time. */ solar?: Solar;
+    /** Air quality indicators at or near the observation site. */ airQuality?: AirQuality;
+    /** Weather alerts that are active for this forecast period and location. */ alerts?: WeatherAlert[];
+};
+/**
+ * Weather observation.
+ *
+ * Represents a real-world measurement or observation at a specific point in time,
+ * typically coming from an instrumented station or human report.
+ */
+export type WeatherObservation = WeatherDataCore & {
+    /** Exact time when the observation was made. */ observedOn: Date;
+    /** Geographic location of the observation. */ location: GeoLocation;
+    /** Observation metadata */ metadata?: {
+        /** Observation source metadata (station, provider, license...). */ source?: ObservationDataSource;
+        /** Time when the data was collected or ingested by the system. */ collectedOn?: Date;
+        /** Human-readable description or summary of the observation. */ description?: string;
+        /** Raw source data as received from the provider. */ rawData?: Record<string, unknown> | string;
+        /** Quality control and processing metadata for the observation. */ observationQuality?: ObservationQualityMetadata;
+    };
+};
+/**
+ * Weather forecast.
+ *
+ * Represents a forecast for a given future period, possibly including a mix
+ * of deterministic and probabilistic information as provided by a model.
+ */
+export type WeatherForecast = WeatherDataCore & {
+    /** Time when the forecast was issued. */ issuedOn: Date;
+    /** Period of time this forecast is valid for. */ validity: ValidityPeriod;
+    /** Geographic location to which the forecast applies. */ location: GeoLocation;
+    /** Observation metadata */ metadata?: {
+        /** Forecast model and source metadata. */ source?: ForecastDataSource;
+        /** Time when the data was collected or ingested by the system. */ collectedOn?: Date;
+        /** Human-readable description or summary of the observation. */ description?: string;
+        /** Raw source data as received from the provider. */ rawData?: Record<string, unknown> | string;
+        /** Associated probabilistic forecast information, if available. */ probabilistic?: ProbabilisticData;
+    };
+};

package/agnostic/weather/types.js

@@ -0,0 +1,8 @@
+/**
+ * Core weather data types for archiving and exchanging meteorological information.
+ *
+ * The structures are inspired by WMO (World Meteorological Organization) guidance
+ * and CF Conventions. Units are encoded explicitly in property names to avoid
+ * ambiguity and to make transformations between systems easier and safer.
+ */
+export {};

package/components/index.d.ts

@@ -1 +1 @@
-export declare namespace Components { }
+export * as utils from './utils/index.js'

package/components/index.js

@@ -0,0 +1 @@
+export * as utils from './utils/index.js'

package/components/public-classnames.d.ts

@@ -0,0 +1,5 @@
+export declare const button = "mxfb-button";
+export declare const input = "mxfb-input";
+export declare const jsonEditor = "mxfb-json-editor";
+export declare const select = "mxfb-select";
+export declare const textarea = "mxfb-textarea";

package/components/public-classnames.js

@@ -0,0 +1,5 @@
+export const button = 'mxfb-button';
+export const input = 'mxfb-input';
+export const jsonEditor = 'mxfb-json-editor';
+export const select = 'mxfb-select';
+export const textarea = 'mxfb-textarea';

package/components/utils/index.d.ts

@@ -0,0 +1 @@
+export declare function mergeClassNames(...names: Array<string | null | undefined | Array<string | null | undefined>>): string;

package/components/utils/index.js

@@ -0,0 +1,12 @@
+export function mergeClassNames(...names) {
+    return names.map(name => {
+        if (typeof name !== 'string' && !Array.isArray(name))
+            return false;
+        if (Array.isArray(name))
+            return mergeClassNames(...name);
+        if (name.trim() === '')
+            return false;
+        return name.trim();
+    }).filter((name) => typeof name === 'string')
+        .join(' ');
+}

package/components/utils/types.d.ts

@@ -0,0 +1,3 @@
+export type WithClassName<T extends Record<string, unknown>> = T & {
+    className?: string | Array<string | null | undefined>;
+};

package/components/utils/types.js

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

package/index.d.ts

@@ -1,3 +1,3 @@
-export { Agnostic } from './agnostic';
-export { Components } from './components';
-export { Node } from './node';
+export * as agnostic from './agnostic/index.js'
+export * as components from './components/index.js'
+export * as node from './node/index.js'

package/index.js

@@ -0,0 +1,3 @@
+export * as agnostic from './agnostic/index.js'
+export * as components from './components/index.js'
+export * as node from './node/index.js'