@design-edito/tools 0.3.0 → 1.0.1

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,194 @@
+import {
+  citiesData
+} from "../../../chunks/chunk-JQLUR5LO.js";
+
+// src/agnostic/scrapers/@meteociel/index.ts
+import { JSDOM } from "jsdom";
+function getCityAndModeUrl(cityName, mode) {
+  const modeUrlChunk = mode === "simple-gfs" ? "previsions" : null;
+  if (modeUrlChunk === null) throw "invalid mode";
+  return `https://www.meteociel.fr/${modeUrlChunk}/${citiesData[cityName].id}/${citiesData[cityName].urlSuffix}.htm`;
+}
+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;
+}
+async function scrap(cityName, mode) {
+  const url = getCityAndModeUrl(cityName, mode);
+  const fetched = await fetchPage(url);
+  switch (mode) {
+    case "simple-gfs": {
+      const scraped = scrapSimpleGfsPrevisions(fetched);
+      return scraped.map((i) => ({
+        ...i,
+        location: {
+          ...i.location,
+          name: cityName
+        }
+      }));
+    }
+    default:
+      throw "unknown-mode";
+  }
+}
+function scrapSimpleGfsPrevisions(pageContent) {
+  const dom = new JSDOM(pageContent);
+  const { document } = dom.window;
+  const COLLECTED_ON = /* @__PURE__ */ new Date();
+  const h3Parent = Array.from(document.querySelectorAll("h3")).find((n) => n.textContent.includes("Pr\xE9visions m\xE9t\xE9o \xE0 3 jours"))?.parentElement;
+  const issueTimeNode = Array.from(h3Parent?.childNodes ?? []).find((n) => n.textContent?.includes("R\xE9actualis\xE9 \xE0"));
+  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\xE9rimentales et d\xE9termin\xE9es \xE0 partir des donn\xE9es brutes de GFS, un mod\xE8le num\xE9rique am\xE9ricain"))?.childNodes ?? []
+  ).find((n) => n.textContent?.startsWith("Localisation de"));
+  const issuedOnRaw = issueTimeNode?.textContent?.match(/\b([0-9]{1,2}):([0-5][0-9])\b/)?.[0];
+  if (issuedOnRaw === void 0) throw "no-refresh-time-found";
+  const [issuedOnH, issuedOnM] = issuedOnRaw.split(":");
+  const issuedOnYesteredayMaybe = /* @__PURE__ */ new Date();
+  issuedOnYesteredayMaybe.setDate((/* @__PURE__ */ new Date()).getDate() - 1);
+  issuedOnYesteredayMaybe.setHours(parseInt(issuedOnH));
+  issuedOnYesteredayMaybe.setMinutes(parseInt(issuedOnM));
+  issuedOnYesteredayMaybe.setSeconds(0);
+  issuedOnYesteredayMaybe.setMilliseconds(0);
+  const issuedOnYesteredayMaybeNowDiff = Math.abs((/* @__PURE__ */ new Date()).getTime() - issuedOnYesteredayMaybe.getTime());
+  const issuedOnTodayMaybe = /* @__PURE__ */ new Date();
+  issuedOnTodayMaybe.setHours(parseInt(issuedOnH));
+  issuedOnTodayMaybe.setMinutes(parseInt(issuedOnM));
+  issuedOnTodayMaybe.setSeconds(0);
+  issuedOnTodayMaybe.setMilliseconds(0);
+  const issuedOnTodayMaybeNowDiff = Math.abs((/* @__PURE__ */ new Date()).getTime() - issuedOnTodayMaybe.getTime());
+  const ISSUED_ON = issuedOnYesteredayMaybeNowDiff > issuedOnTodayMaybeNowDiff ? issuedOnTodayMaybe : issuedOnYesteredayMaybe;
+  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/;
+    const match = input.match(regex);
+    if (!match) throw new Error("Format de coordonn\xE9es 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 "no-geolocation-found";
+  }
+  let currentDateLabel = null;
+  const currentHour = /* @__PURE__ */ new Date();
+  currentHour.setMinutes(0);
+  currentHour.setSeconds(0);
+  currentHour.setMilliseconds(0);
+  let RETURNED = [];
+  for (const row of forecastTableRows) {
+    const cells = Array.from(row.querySelectorAll("td"));
+    if (cells.length < 10 || cells.length > 11) continue;
+    let dateCell = void 0;
+    let otherCells = [];
+    if (cells.length === 11) {
+      dateCell = cells[0];
+      otherCells.push(...cells.slice(1));
+    } else {
+      otherCells.push(...cells);
+    }
+    if (dateCell !== void 0) {
+      currentDateLabel = dateCell.textContent;
+    }
+    const [
+      hourCell,
+      tempCell,
+      _emptyCell1,
+      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 [windDirName = null, 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;
+    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
+    };
+    const TEMPERATURE = { tempC: parseFloat(temp?.replace(" \xB0C", "") ?? "") };
+    const HUMIDITY = { relativePercent: parseFloat(hygrometry?.replace(" %", "") ?? "") };
+    const WIND = {
+      speedMs: parseFloat(windSpeed ?? ""),
+      directionDeg: parseFloat(windDirAngle?.replace(" \xB0", "") ?? ""),
+      gustMs: parseFloat(gustSpeed ?? "")
+    };
+    const PRESSURE = { stationLevelHpa: parseFloat(airPressure?.replace(" hPa", "") ?? "") };
+    const SOURCE = {
+      provider: "M\xE9t\xE9ociel",
+      type: "model",
+      model: "GFS"
+    };
+    RETURNED.push({
+      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;
+}
+export {
+  fetchPage,
+  getCityAndModeUrl,
+  scrap,
+  scrapSimpleGfsPrevisions
+};

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,6 @@
+import {
+  citiesData
+} from "../../../../chunks/chunk-JQLUR5LO.js";
+export {
+  citiesData
+};

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

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

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, any> | 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, any> | string;
+        /** Associated probabilistic forecast information, if available. */ probabilistic?: ProbabilisticData;
+    };
+};

package/chunks/chunk-JQLUR5LO.js

@@ -0,0 +1,12 @@
+// src/agnostic/scrapers/@meteociel/locations/index.ts
+var citiesData = {
+  // Paris 11e
+  "paris11": {
+    id: 27827,
+    urlSuffix: "paris_11eme_arrondissement"
+  }
+};
+
+export {
+  citiesData
+};

package/components/Comp/index.d.ts

@@ -1 +1 @@
-export default function Comp(): import("react/jsx-runtime").JSX.Element;
+export {};

package/components/Comp/index.js

@@ -1,10 +0,0 @@
-import "../../chunks/chunk-XCBH6NLF.js";
-
-// src/components/Comp/index.tsx
-import { Fragment, jsx } from "react/jsx-runtime";
-function Comp() {
-  return /* @__PURE__ */ jsx(Fragment, { children: "Coucou !" });
-}
-export {
-  Comp as default
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@design-edito/tools",
-  "version": "0.3.0",
+  "version": "1.0.1",
   "description": "",
   "author": "Maxime Fabas",
   "license": "ISC",
@@ -14,6 +14,7 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.907.0",
     "@aws-sdk/lib-storage": "^3.907.0",
+    "@design-edito/tools": "^0.2.41",
     "@google-cloud/storage": "^7.17.2",
     "@inquirer/prompts": "^8.2.0",
     "ansi-regex": "^6.2.2",

package/agnostic/arrays/dedupe/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * Returns a copy of the input array, with stripped duplicates
- *
- * @param arr - The array to search for duplicates.
- * @returns The deduped array
- */
-export declare function dedupe<T>(arr: T[]): T[];

package/agnostic/arrays/dedupe/index.js

@@ -1,10 +0,0 @@
-import "../../../chunks/chunk-XCBH6NLF.js";
-
-// src/agnostic/arrays/dedupe/index.ts
-function dedupe(arr) {
-  const deduped = Array.from(new Set(arr));
-  return deduped;
-}
-export {
-  dedupe
-};

package/agnostic/arrays/find-duplicates/index.d.ts

@@ -1,15 +0,0 @@
-/**
- * Finds duplicate elements in an array.
- *
- * @param arr - The array to search for duplicates.
- * @param [stopAtFirst=false] - If `true`, returns immediately after finding the first duplicate.
- * @returns An array of duplicate elements found in the input array.
- */
-export declare function findDuplicates<T>(arr: T[], stopAtFirst?: boolean): T[];
-/**
- * Finds the positions of duplicate elements in an array.
- *
- * @param arr - The array to search for duplicates positions.
- * @returns An array of the positions of duplicate elements found in the input array.
- */
-export declare function findDuplicatesPositions(arr: any[]): number[];

package/agnostic/arrays/find-duplicates/index.js

@@ -1,26 +0,0 @@
-import "../../../chunks/chunk-XCBH6NLF.js";
-
-// src/agnostic/arrays/find-duplicates/index.ts
-function findDuplicates(arr, stopAtFirst = false) {
-  const seen = /* @__PURE__ */ new Set();
-  const duplicates = /* @__PURE__ */ new Set();
-  for (const item of arr) {
-    if (seen.has(item) && stopAtFirst) return [item];
-    if (seen.has(item)) duplicates.add(item);
-    seen.add(item);
-  }
-  return Array.from(duplicates);
-}
-function findDuplicatesPositions(arr) {
-  const seen = /* @__PURE__ */ new Set();
-  const duplicatesPos = [];
-  arr.forEach((item, pos) => {
-    if (seen.has(item)) return duplicatesPos.push(pos);
-    seen.add(item);
-  });
-  return duplicatesPos;
-}
-export {
-  findDuplicates,
-  findDuplicatesPositions
-};

package/agnostic/arrays/find-duplicates/index.test.d.ts

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

package/agnostic/arrays/is-array-of/index.d.ts

@@ -1,16 +0,0 @@
-import { type ConstructorFunction } from '../../misc/is-constructor-function/index.js';
-/** Type guard function that checks if input is of type T. */
-type TypeCheckerFunction<T> = (input: unknown) => input is T;
-/** Type checker that can be either a constructor function or a type guard function. */
-type TypeChecker<T> = ConstructorFunction<T> | TypeCheckerFunction<T>;
-/** Infer the type from a TypeChecker */
-type TypeOfChecker<C> = C extends ConstructorFunction<infer U> ? U : C extends TypeCheckerFunction<infer U> ? U : never;
-/**
- * Type guard to check if an input is an array and optionally if all elements match a type.
- *
- * If no type checkers are provided, only checks if the input is an array.
- * Supports constructor functions (e.g., `Number`, `String`, `Boolean`, custom classes)
- * and custom type guard functions.
- */
-export declare function isArrayOf<C extends TypeChecker<any> | TypeChecker<any>[]>(input: unknown, _types?: C): input is Array<TypeOfChecker<C extends any[] ? C[number] : C>>;
-export {};

package/agnostic/arrays/is-array-of/index.js

@@ -1,27 +0,0 @@
-import {
-  isConstructorFunction
-} from "../../../chunks/chunk-RCO57B6F.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
-
-// src/agnostic/arrays/is-array-of/index.ts
-function isArrayOf(input, _types) {
-  if (!Array.isArray(input)) return false;
-  if (!_types) return true;
-  const types = Array.isArray(_types) ? _types : [_types];
-  const primitiveTypeMap = /* @__PURE__ */ new Map([
-    [Number, "number"],
-    [String, "string"],
-    [Boolean, "boolean"]
-  ]);
-  return input.every(
-    (entry) => types.some((typeChecker) => {
-      if (!isConstructorFunction(typeChecker)) return typeChecker(entry);
-      const primitiveType = primitiveTypeMap.get(typeChecker);
-      if (primitiveType) return typeof entry === primitiveType;
-      return entry instanceof typeChecker;
-    })
-  );
-}
-export {
-  isArrayOf
-};

package/agnostic/arrays/is-array-of/index.test.d.ts

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

package/agnostic/arrays/make/index.d.ts

@@ -1,11 +0,0 @@
-/** Function that generates a value for each array position. */
-type Filler<T = any> = (pos?: number) => T;
-/**
- * Creates an array of a specified length using a filler function.
- *
- * @param filler - Function called for each position to generate the array element.
- * @param length - Desired length of the array.
- * @returns A new array with elements generated by the filler function.
- */
-export declare function make<T>(filler: Filler<T>, length: number): T[];
-export {};

package/agnostic/arrays/make/index.js

@@ -1,9 +0,0 @@
-import "../../../chunks/chunk-XCBH6NLF.js";
-
-// src/agnostic/arrays/make/index.ts
-function make(filler, length) {
-  return new Array(length).fill(null).map((_, pos) => filler(pos));
-}
-export {
-  make
-};

package/agnostic/arrays/make/index.test.d.ts

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

package/agnostic/arrays/random-pick/index.d.ts

@@ -1,22 +0,0 @@
-/**
- * Picks a random element from an array, optionally excluding certain elements.
- *
- * @param arr - The array to pick from.
- * @param [exclude] - Array of elements to exclude from selection.
- * @returns A randomly selected element from the array.
- * @throws Throws an error if no elements are available after exclusions.
- */
-export declare function randomPick<T>(arr: T[], exclude?: T[]): T;
-/**
- * Picks multiple random elements from an array without replacement.
- *
- * Each picked element is removed from the pool before the next selection, ensuring
- * no duplicates in the result.
- *
- * @param howMuch - Number of elements to pick.
- * @param arr - The array to pick from.
- * @param [exclude] - Array of elements to exclude from selection.
- * @returns An array of randomly selected elements.
- * @throws Propagates the error thrown by `randomPick` if not enough elements are available.
- */
-export declare function randomPickMany<T>(howMuch: number, arr: T[], exclude?: T[]): T[];

package/agnostic/arrays/random-pick/index.js

@@ -1,9 +0,0 @@
-import {
-  randomPick,
-  randomPickMany
-} from "../../../chunks/chunk-K5UF634H.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
-export {
-  randomPick,
-  randomPickMany
-};