@nshiab/simple-data-analysis 5.19.8

package/script/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/logDotChart.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = logDotChart;
+const addDots_js_1 = __importDefault(require("./helpers/addDots.js"));
+const prepChart_js_1 = __importDefault(require("./helpers/prepChart.js"));
+/**
+ * Generates and logs a text-based dot chart to the console. This function is ideal for visualizing the relationship between two numerical variables. It provides a quick, terminal-friendly way to inspect data trends and distributions.
+ *
+ * The chart is rendered using ASCII characters, ensuring compatibility across various terminal environments. It supports custom formatting for both x and y-axis values, and can generate small multiples to compare distributions across different categories. While the function expects data to be sorted by the x-axis values for proper rendering, it does not enforce this.
+ *
+ * **Data Type Requirements:**
+ * - **X-axis values**: Must be `number` or `Date` objects.
+ * - **Y-axis values**: Must be `number` values.
+ * - All values must be non-null and defined.
+ *
+ * @param data - An array of objects representing the data to be visualized. Each object should contain keys corresponding to the `x` and `y` parameters.
+ * @param x - The key in the data objects whose values will be plotted on the x-axis. Values must be numbers or Date objects.
+ * @param y - The key in the data objects whose values will be plotted on the y-axis. Values must be numbers.
+ * @param options - An optional object to customize the chart's appearance and behavior.
+ * @param options.formatX - A function to format the x-axis values for display. It receives the raw x-value as input and should return a string. If the first data point's x value is a Date, it defaults to formatting the date as "YYYY-MM-DD".
+ * @param options.formatY - A function to format the y-axis values for display. It receives the raw y-value as input and should return a string.
+ * @param options.smallMultiples - A key in the data objects to create small multiples (separate charts) for each unique value of this key. This is useful for comparing trends across different categories.
+ * @param options.fixedScales - If `true` and `smallMultiples` is used, all small multiple charts will share the same x and y scales, allowing for direct comparison of magnitudes. If `false`, each small multiple will have its own independent scales. Defaults to `false`.
+ * @param options.smallMultiplesPerRow - The number of small multiples to display per row when `smallMultiples` is used. Defaults to `3`.
+ * @param options.width - The width of the chart in characters. This affects the horizontal resolution of the chart. Defaults to `60`.
+ * @param options.height - The height of the chart in lines. This affects the vertical resolution of the chart. Defaults to `20`.
+ * @param options.title - The title of the chart. If not provided, a default title based on `x`, `y`, and `smallMultiples` (if applicable) will be generated.
+ *
+ * @example
+ * ```ts
+ * // Visualize a time series of values.
+ * const timeSeriesData = [
+ *     { date: new Date("2023-01-01"), value: 10 },
+ *     { date: new Date("2023-02-01"), value: 20 },
+ *     { date: new Date("2023-03-01"), value: 30 },
+ *     { date: new Date("2023-04-01"), value: 40 },
+ * ];
+ *
+ * logDotChart(timeSeriesData, "date", "value", {
+ *     formatX: (d) => (d as Date).toISOString().slice(0, 10),
+ *     formatY: (d) => "$" + (d as number).toString(),
+ *     title: "Monthly Sales Trend",
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Compare trends across different categories using small multiples.
+ * const multiCategoryData = [
+ *     { date: new Date("2023-01-01"), value: 10, category: "A" },
+ *     { date: new Date("2023-02-01"), value: 20, category: "A" },
+ *     { date: new Date("2023-03-01"), value: 30, category: "A" },
+ *     { date: new Date("2023-04-01"), value: 40, category: "A" },
+ *     { date: new Date("2023-01-01"), value: 15, category: "B" },
+ *     { date: new Date("2023-02-01"), value: 25, category: "B" },
+ *     { date: new Date("2023-03-01"), value: 35, category: "B" },
+ *     { date: new Date("2023-04-01"), value: 45, category: "B" },
+ * ];
+ *
+ * logDotChart(multiCategoryData, "date", "value", {
+ *     formatX: (d) => (d as Date).toISOString().slice(0, 10),
+ *     formatY: (d) => "$" + (d as number).toString(),
+ *     smallMultiples: "category",
+ *     smallMultiplesPerRow: 2,
+ *     fixedScales: true,
+ *     title: "Sales Trend by Category",
+ * });
+ * ```
+ *
+ * @returns {void}
+ * @category Dataviz
+ */
+function logDotChart(data, x, y, options = {}) {
+    if (options.title) {
+        console.log(`\n${options.title}`);
+    }
+    else {
+        console.log(`\nDot chart of "${String(y)}" over "${String(x)}"${options.smallMultiples
+            ? `, for each "${String(options.smallMultiples)}"`
+            : ""}:`);
+    }
+    (0, prepChart_js_1.default)("dot", data, String(x), String(y), addDots_js_1.default, {
+        ...options,
+        formatX: options.formatX
+            ? (d) => options.formatX(d)
+            : undefined,
+        formatY: options.formatY
+            ? (d) => options.formatY(d)
+            : undefined,
+        smallMultiples: options.smallMultiples
+            ? String(options.smallMultiples)
+            : undefined,
+    });
+}

package/script/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/logLineChart.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Generates and logs a text-based line chart to the console. This function is particularly useful for visualizing trends over time providing a quick and accessible way to understand data progression directly within a terminal or log output.
+ *
+ * The chart is rendered using ASCII characters, ensuring broad compatibility. It supports custom formatting for both x and y-axis values, and can generate small multiples to compare trends across different categories. When the chart's width is smaller than the number of data points, the line represents an averaged approximation of the data, providing a smoothed view of the trend. For optimal visualization, it's recommended that the input `data` be sorted by the x-axis values.
+ *
+ * **Data Type Requirements:**
+ * - **X-axis values**: Must be `number` or `Date` objects.
+ * - **Y-axis values**: Must be `number` values.
+ * - All values must be non-null and defined.
+ *
+ * @param data - An array of objects representing the data to be visualized. Each object should contain keys corresponding to the `x` and `y` parameters.
+ * @param x - The key in the data objects whose values will be plotted on the x-axis. Values must be numbers or Date objects.
+ * @param y - The key in the data objects whose values will be plotted on the y-axis. Values must be numbers.
+ * @param options - An optional object to customize the chart's appearance and behavior.
+ * @param options.formatX - A function to format the x-axis values for display. It receives the raw x-value as input and should return a string. If the first data point's x value is a Date, it defaults to formatting the date as "YYYY-MM-DD".
+ * @param options.formatY - A function to format the y-axis values for display. It receives the raw y-value as input and should return a string.
+ * @param options.smallMultiples - A key in the data objects to create small multiples (separate charts) for each unique value of this key. This is useful for comparing trends across different categories.
+ * @param options.fixedScales - If `true` and `smallMultiples` is used, all small multiple charts will share the same x and y scales, allowing for direct comparison of magnitudes. If `false`, each small multiple will have its own independent scales. Defaults to `false`.
+ * @param options.smallMultiplesPerRow - The number of small multiples to display per row when `smallMultiples` is used. Defaults to `3`.
+ * @param options.width - The width of the chart in characters. This affects the horizontal resolution of the chart. Defaults to `60`.
+ * @param options.height - The height of the chart in lines. This affects the vertical resolution of the chart. Defaults to `20`.
+ * @param options.title - The title of the chart. If not provided, a default title based on `x`, `y`, and `smallMultiples` (if applicable) will be generated.
+ *
+ * @example
+ * ```ts
+ * // Visualize a simple time series of values.
+ * const timeSeriesData = [
+ *     { date: new Date("2023-01-01"), value: 10 },
+ *     { date: new Date("2023-02-01"), value: 20 },
+ *     { date: new Date("2023-03-01"), value: 30 },
+ *     { date: new Date("2023-04-01"), value: 40 },
+ * ];
+ *
+ * logLineChart(timeSeriesData, "date", "value", {
+ *     formatX: (d) => (d as Date).toISOString().slice(0, 10),
+ *     title: "Monthly Data Trend",
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Compare trends across different categories using small multiples.
+ * const multiCategoryData = [
+ *     { date: new Date("2023-01-01"), value: 10, category: "A" },
+ *     { date: new Date("2023-02-01"), value: 20, category: "A" },
+ *     { date: new Date("2023-03-01"), value: 30, category: "A" },
+ *     { date: new Date("2023-04-01"), value: 40, category: "A" },
+ *     { date: new Date("2023-01-01"), value: 15, category: "B" },
+ *     { date: new Date("2023-02-01"), value: 25, category: "B" },
+ *     { date: new Date("2023-03-01"), value: 35, category: "B" },
+ *     { date: new Date("2023-04-01"), value: 45, category: "B" },
+ * ];
+ *
+ * logLineChart(multiCategoryData, "date", "value", {
+ *     formatX: (d) => (d as Date).toLocaleDateString(),
+ *     formatY: (d) => "$" + (d as number).toString(),
+ *     smallMultiples: "category",
+ *     smallMultiplesPerRow: 2,
+ *     fixedScales: true,
+ *     title: "Sales Trend by Category",
+ * });
+ * ```
+ *
+ * @returns {void}
+ * @category Dataviz
+ */
+export default function logLineChart<T extends Record<string, unknown>>(data: T[], x: keyof T, y: keyof T, options?: {
+    formatX?: (d: T[typeof x]) => string;
+    formatY?: (d: T[typeof y]) => string;
+    smallMultiples?: keyof T;
+    fixedScales?: boolean;
+    smallMultiplesPerRow?: number;
+    width?: number;
+    height?: number;
+    title?: string;
+}): void;
+//# sourceMappingURL=logLineChart.d.ts.map

package/script/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/logLineChart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logLineChart.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/logLineChart.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpE,IAAI,EAAE,CAAC,EAAE,EACT,CAAC,EAAE,MAAM,CAAC,EACV,CAAC,EAAE,MAAM,CAAC,EACV,OAAO,GAAE;IACP,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,KAAK,MAAM,CAAC;IACrC,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,KAAK,MAAM,CAAC;IACrC,cAAc,CAAC,EAAE,MAAM,CAAC,CAAC;IACzB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CACX,GACL,IAAI,CAyBN"}

package/script/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/logLineChart.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = logLineChart;
+const addLines_js_1 = __importDefault(require("./helpers/addLines.js"));
+const prepChart_js_1 = __importDefault(require("./helpers/prepChart.js"));
+/**
+ * Generates and logs a text-based line chart to the console. This function is particularly useful for visualizing trends over time providing a quick and accessible way to understand data progression directly within a terminal or log output.
+ *
+ * The chart is rendered using ASCII characters, ensuring broad compatibility. It supports custom formatting for both x and y-axis values, and can generate small multiples to compare trends across different categories. When the chart's width is smaller than the number of data points, the line represents an averaged approximation of the data, providing a smoothed view of the trend. For optimal visualization, it's recommended that the input `data` be sorted by the x-axis values.
+ *
+ * **Data Type Requirements:**
+ * - **X-axis values**: Must be `number` or `Date` objects.
+ * - **Y-axis values**: Must be `number` values.
+ * - All values must be non-null and defined.
+ *
+ * @param data - An array of objects representing the data to be visualized. Each object should contain keys corresponding to the `x` and `y` parameters.
+ * @param x - The key in the data objects whose values will be plotted on the x-axis. Values must be numbers or Date objects.
+ * @param y - The key in the data objects whose values will be plotted on the y-axis. Values must be numbers.
+ * @param options - An optional object to customize the chart's appearance and behavior.
+ * @param options.formatX - A function to format the x-axis values for display. It receives the raw x-value as input and should return a string. If the first data point's x value is a Date, it defaults to formatting the date as "YYYY-MM-DD".
+ * @param options.formatY - A function to format the y-axis values for display. It receives the raw y-value as input and should return a string.
+ * @param options.smallMultiples - A key in the data objects to create small multiples (separate charts) for each unique value of this key. This is useful for comparing trends across different categories.
+ * @param options.fixedScales - If `true` and `smallMultiples` is used, all small multiple charts will share the same x and y scales, allowing for direct comparison of magnitudes. If `false`, each small multiple will have its own independent scales. Defaults to `false`.
+ * @param options.smallMultiplesPerRow - The number of small multiples to display per row when `smallMultiples` is used. Defaults to `3`.
+ * @param options.width - The width of the chart in characters. This affects the horizontal resolution of the chart. Defaults to `60`.
+ * @param options.height - The height of the chart in lines. This affects the vertical resolution of the chart. Defaults to `20`.
+ * @param options.title - The title of the chart. If not provided, a default title based on `x`, `y`, and `smallMultiples` (if applicable) will be generated.
+ *
+ * @example
+ * ```ts
+ * // Visualize a simple time series of values.
+ * const timeSeriesData = [
+ *     { date: new Date("2023-01-01"), value: 10 },
+ *     { date: new Date("2023-02-01"), value: 20 },
+ *     { date: new Date("2023-03-01"), value: 30 },
+ *     { date: new Date("2023-04-01"), value: 40 },
+ * ];
+ *
+ * logLineChart(timeSeriesData, "date", "value", {
+ *     formatX: (d) => (d as Date).toISOString().slice(0, 10),
+ *     title: "Monthly Data Trend",
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Compare trends across different categories using small multiples.
+ * const multiCategoryData = [
+ *     { date: new Date("2023-01-01"), value: 10, category: "A" },
+ *     { date: new Date("2023-02-01"), value: 20, category: "A" },
+ *     { date: new Date("2023-03-01"), value: 30, category: "A" },
+ *     { date: new Date("2023-04-01"), value: 40, category: "A" },
+ *     { date: new Date("2023-01-01"), value: 15, category: "B" },
+ *     { date: new Date("2023-02-01"), value: 25, category: "B" },
+ *     { date: new Date("2023-03-01"), value: 35, category: "B" },
+ *     { date: new Date("2023-04-01"), value: 45, category: "B" },
+ * ];
+ *
+ * logLineChart(multiCategoryData, "date", "value", {
+ *     formatX: (d) => (d as Date).toLocaleDateString(),
+ *     formatY: (d) => "$" + (d as number).toString(),
+ *     smallMultiples: "category",
+ *     smallMultiplesPerRow: 2,
+ *     fixedScales: true,
+ *     title: "Sales Trend by Category",
+ * });
+ * ```
+ *
+ * @returns {void}
+ * @category Dataviz
+ */
+function logLineChart(data, x, y, options = {}) {
+    if (options.title) {
+        console.log(`\n${options.title}`);
+    }
+    else {
+        console.log(`\nLine chart of "${String(y)}" over "${String(x)}"${options.smallMultiples
+            ? `, for each "${String(options.smallMultiples)}"`
+            : ""}:`);
+    }
+    (0, prepChart_js_1.default)("line", data, String(x), String(y), addLines_js_1.default, {
+        ...options,
+        formatX: options.formatX
+            ? (d) => options.formatX(d)
+            : undefined,
+        formatY: options.formatY
+            ? (d) => options.formatY(d)
+            : undefined,
+        smallMultiples: options.smallMultiples
+            ? String(options.smallMultiples)
+            : undefined,
+    });
+}

package/script/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/publishChartDW.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Publishes a specified Datawrapper chart, table, or map. This function streamlines the process of making your Datawrapper visualizations live, allowing for automated deployment and updates. It handles authentication using an API key, which can be provided via environment variables or directly through options.
+ *
+ * @param chartId - The unique ID of the Datawrapper chart, table, or map to be published. This ID can be found in the Datawrapper URL or dashboard.
+ * @param options - Optional parameters to configure the publishing process.
+ *   @param options.apiKey - The name of the environment variable that stores your Datawrapper API key (e.g., `"DATAWRAPPER_KEY"`). If not provided, the function defaults to looking for the `DATAWRAPPER_KEY` environment variable.
+ *   @param options.returnResponse - If `true`, the function will return the full `Response` object from the Datawrapper API call. This can be useful for debugging or for more detailed handling of the API response. Defaults to `false`.
+ * @returns A Promise that resolves to `void` if `returnResponse` is `false` (default), or a `Response` object if `returnResponse` is `true`.
+ *
+ * @example
+ * ```ts
+ * // Publish a Datawrapper chart with a given ID.
+ * const chartID = "myChartId";
+ * await publishChartDW(chartID);
+ * console.log(`Chart ${chartID} published successfully.`);
+ * ```
+ * @example
+ * ```ts
+ * // If your Datawrapper API key is stored under a different environment variable name (e.g., `DW_API_KEY`).
+ * const customApiKeyChartID = "anotherChartId";
+ * await publishChartDW(customApiKeyChartID, { apiKey: "DW_API_KEY" });
+ * console.log(`Chart ${customApiKeyChartID} published using custom API key.`);
+ * ```
+ * @example
+ * ```ts
+ * // Get the full HTTP response object after publishing.
+ * const chartIDForResponse = "yetAnotherChartId";
+ * const response = await publishChartDW(chartIDForResponse, { returnResponse: true });
+ * console.log(`Response status for ${chartIDForResponse}: ${response?.status}`);
+ * ```
+ * @category Dataviz
+ */
+export default function publishChartDW(chartId: string, options?: {
+    apiKey?: string;
+    returnResponse?: boolean;
+}): Promise<void | Response>;
+//# sourceMappingURL=publishChartDW.d.ts.map

package/script/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/publishChartDW.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publishChartDW.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/publishChartDW.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAA8B,cAAc,CAC1C,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GAC1D,OAAO,CAAC,IAAI,GAAG,QAAQ,CAAC,CA4B1B"}

package/script/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/publishChartDW.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = publishChartDW;
+const node_process_1 = __importDefault(require("node:process"));
+/**
+ * Publishes a specified Datawrapper chart, table, or map. This function streamlines the process of making your Datawrapper visualizations live, allowing for automated deployment and updates. It handles authentication using an API key, which can be provided via environment variables or directly through options.
+ *
+ * @param chartId - The unique ID of the Datawrapper chart, table, or map to be published. This ID can be found in the Datawrapper URL or dashboard.
+ * @param options - Optional parameters to configure the publishing process.
+ *   @param options.apiKey - The name of the environment variable that stores your Datawrapper API key (e.g., `"DATAWRAPPER_KEY"`). If not provided, the function defaults to looking for the `DATAWRAPPER_KEY` environment variable.
+ *   @param options.returnResponse - If `true`, the function will return the full `Response` object from the Datawrapper API call. This can be useful for debugging or for more detailed handling of the API response. Defaults to `false`.
+ * @returns A Promise that resolves to `void` if `returnResponse` is `false` (default), or a `Response` object if `returnResponse` is `true`.
+ *
+ * @example
+ * ```ts
+ * // Publish a Datawrapper chart with a given ID.
+ * const chartID = "myChartId";
+ * await publishChartDW(chartID);
+ * console.log(`Chart ${chartID} published successfully.`);
+ * ```
+ * @example
+ * ```ts
+ * // If your Datawrapper API key is stored under a different environment variable name (e.g., `DW_API_KEY`).
+ * const customApiKeyChartID = "anotherChartId";
+ * await publishChartDW(customApiKeyChartID, { apiKey: "DW_API_KEY" });
+ * console.log(`Chart ${customApiKeyChartID} published using custom API key.`);
+ * ```
+ * @example
+ * ```ts
+ * // Get the full HTTP response object after publishing.
+ * const chartIDForResponse = "yetAnotherChartId";
+ * const response = await publishChartDW(chartIDForResponse, { returnResponse: true });
+ * console.log(`Response status for ${chartIDForResponse}: ${response?.status}`);
+ * ```
+ * @category Dataviz
+ */
+async function publishChartDW(chartId, options = {}) {
+    const envVar = options.apiKey ?? "DATAWRAPPER_KEY";
+    const apiKey = node_process_1.default.env[envVar];
+    if (apiKey === undefined || apiKey === "") {
+        throw new Error(`process.env.${envVar} is undefined or ''.`);
+    }
+    const response = await fetch(`https://api.datawrapper.de/v3/charts/${chartId}/publish`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+        },
+    });
+    await response.json();
+    // if returning a response, do it before the response.status checks
+    if (options.returnResponse === true) {
+        return response;
+    }
+    if (response.status !== 200) {
+        throw new Error(`publishChartDW ${chartId}: Upstream HTTP ${response.status} - ${response.statusText}`);
+    }
+}

package/script/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/rewind.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Rewinds the winding order of the specified GeoJSON object to be clockwise. It is based on the D3-geo library's winding order conventions.
+ *
+ * @param object - The GeoJSON object to rewind.
+ * @returns A new GeoJSON object.
+ *
+ * @example
+ * ```ts
+ * // Rewind a FeatureCollection.
+ * const featureCollection = {
+ *   type: "FeatureCollection",
+ *   features: [
+ *     {
+ *       type: "Feature",
+ *       properties: {},
+ *       geometry: {
+ *         type: "Polygon",
+ *         coordinates: [[[-10, -10], [-10, 10], [10, 10], [10, -10], [-10, -10]]]
+ *       }
+ *     }
+ *   ]
+ * };
+ * const rewoundFeatureCollection = rewind(featureCollection);
+ * ```
+ * @example
+ * ```ts
+ * // Rewind a GeoJSON Feature containing a Polygon geometry.
+ * const feature = {
+ *   type: "Feature",
+ *   properties: { name: "Example Area" },
+ *   geometry: {
+ *     type: "Polygon",
+ *     coordinates: [[[-5, -5], [-5, 5], [5, 5], [5, -5], [-5, -5]]]
+ *   }
+ * };
+ * const rewoundFeature = rewind(feature);
+ * console.log(rewoundFeature);
+ * ```
+ * @category Geo
+ */
+export default function rewind(object: any): any;
+//# sourceMappingURL=rewind.d.ts.map

package/script/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/rewind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewind.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/rewind.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,CAAC,OAAO,UAAU,MAAM,CAE5B,MAAM,EAAE,GAAG,GAEV,GAAG,CAiBL"}

package/script/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/rewind.js

@@ -0,0 +1,180 @@
+"use strict";
+// Based on https://observablehq.com/@fil/rewind
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = rewind;
+/* @ts-types="npm:@types/d3-geo@^3.1.0" */ const d3_geo_1 = require("d3-geo");
+/**
+ * Rewinds the winding order of the specified GeoJSON object to be clockwise. It is based on the D3-geo library's winding order conventions.
+ *
+ * @param object - The GeoJSON object to rewind.
+ * @returns A new GeoJSON object.
+ *
+ * @example
+ * ```ts
+ * // Rewind a FeatureCollection.
+ * const featureCollection = {
+ *   type: "FeatureCollection",
+ *   features: [
+ *     {
+ *       type: "Feature",
+ *       properties: {},
+ *       geometry: {
+ *         type: "Polygon",
+ *         coordinates: [[[-10, -10], [-10, 10], [10, 10], [10, -10], [-10, -10]]]
+ *       }
+ *     }
+ *   ]
+ * };
+ * const rewoundFeatureCollection = rewind(featureCollection);
+ * ```
+ * @example
+ * ```ts
+ * // Rewind a GeoJSON Feature containing a Polygon geometry.
+ * const feature = {
+ *   type: "Feature",
+ *   properties: { name: "Example Area" },
+ *   geometry: {
+ *     type: "Polygon",
+ *     coordinates: [[[-5, -5], [-5, 5], [5, 5], [5, -5], [-5, -5]]]
+ *   }
+ * };
+ * const rewoundFeature = rewind(feature);
+ * console.log(rewoundFeature);
+ * ```
+ * @category Geo
+ */
+function rewind(
+// deno-lint-ignore no-explicit-any
+object) {
+    const projection = geoRewindStream();
+    const stream = projection.stream;
+    let project;
+    if (!stream)
+        throw new Error("invalid projection");
+    switch (object && object.type) {
+        case "Feature":
+            project = projectFeature;
+            break;
+        case "FeatureCollection":
+            project = projectFeatureCollection;
+            break;
+        default:
+            project = projectGeometry;
+            break;
+    }
+    return project(object, stream);
+}
+function geoRewindStream() {
+    let ring;
+    // @ts-ignore To do
+    let polygon;
+    return (0, d3_geo_1.geoTransform)({
+        polygonStart() {
+            this.stream.polygonStart();
+            polygon = [];
+        },
+        lineStart() {
+            // @ts-ignore To do
+            if (polygon)
+                polygon.push(ring = []);
+            else
+                this.stream.lineStart();
+        },
+        lineEnd() {
+            // @ts-ignore To do
+            if (!polygon)
+                this.stream.lineEnd();
+        },
+        point(x, y) {
+            // @ts-ignore To do
+            if (polygon)
+                ring.push([x, y]);
+            else
+                this.stream.point(x, y);
+        },
+        polygonEnd() {
+            // @ts-ignore To do
+            for (const [i, ring] of polygon.entries()) {
+                ring.push(ring[0].slice());
+                if (i
+                    // a hole must contain the first point of the polygon
+                    ? !(0, d3_geo_1.geoContains)({ type: "Polygon", coordinates: [ring] }, 
+                    // @ts-ignore To do
+                    polygon[0][0])
+                    // @ts-ignore To do
+                    : polygon[1]
+                        // the outer ring must contain the first point of its first hole (if any)
+                        ? !(0, d3_geo_1.geoContains)({ type: "Polygon", coordinates: [ring] }, 
+                        // @ts-ignore To do
+                        polygon[1][0])
+                        // a single ring polygon must be smaller than a hemisphere (optional)
+                        : (0, d3_geo_1.geoArea)({ type: "Polygon", coordinates: [ring] }) >
+                            2 * Math.PI) {
+                    ring.reverse();
+                }
+                this.stream.lineStart();
+                ring.pop();
+                for (const [x, y] of ring)
+                    this.stream.point(x, y);
+                this.stream.lineEnd();
+            }
+            this.stream.polygonEnd();
+            polygon = null;
+        },
+    });
+}
+// @ts-ignore To do
+function projectFeatureCollection(o, stream) {
+    // @ts-ignore To do
+    return { ...o, features: o.features.map((f) => projectFeature(f, stream)) };
+}
+// @ts-ignore To do
+function projectFeature(o, stream) {
+    return { ...o, geometry: projectGeometry(o.geometry, stream) };
+}
+// @ts-ignore To do
+function projectGeometryCollection(o, stream) {
+    return {
+        ...o,
+        // @ts-ignore To do
+        geometries: o.geometries.map((o) => projectGeometry(o, stream)),
+    };
+}
+// @ts-ignore To do
+function projectGeometry(o, stream) {
+    return !o
+        ? null
+        : o.type === "GeometryCollection"
+            ? projectGeometryCollection(o, stream)
+            : o.type === "Polygon" || o.type === "MultiPolygon"
+                ? projectPolygons(o, stream)
+                : o;
+}
+// @ts-ignore To do
+function projectPolygons(o, stream) {
+    // @ts-ignore To do
+    let coordinates = [];
+    // @ts-ignore To do
+    let polygon, line;
+    (0, d3_geo_1.geoStream)(o, stream({
+        polygonStart() {
+            coordinates.push(polygon = []);
+        },
+        polygonEnd() { },
+        lineStart() {
+            polygon.push(line = []);
+        },
+        lineEnd() {
+            // @ts-ignore To do
+            line.push(line[0].slice());
+        },
+        // @ts-ignore To do
+        point(x, y) {
+            line.push([x, y]);
+        },
+    }));
+    // @ts-ignore To do
+    if (o.type === "Polygon")
+        coordinates = coordinates[0];
+    return { ...o, coordinates };
+}

package/script/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/saveChart.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Saves an [Observable Plot](https://github.com/observablehq/plot) chart as an image file (`.png`) or an SVG file (`.svg`).
+ *
+ * @param data - An array of data objects that your Observable Plot chart function expects.
+ * @param chart - A function that takes the `data` array and returns an SVG or HTML element representing the chart. Inside this function, `d3`, `Plot`, and `journalismFormat` globals are available, with their members destructured (e.g. `formatNumber`, `formatDate`, `round` from journalism-format; `min`, `max`, `mean`, etc. from d3; and all Plot marks).
+ * @param path - The file path where the image or SVG will be saved. The file extension (`.png` or `.svg`) determines the output format.
+ * @param options - Optional settings to customize the chart's appearance and behavior.
+ *   @param options.style - A CSS string to apply custom styles to the chart.
+ *   @param options.dark - If `true`, the chart will be rendered with a dark mode theme. Defaults to `false`.
+ * @returns A Promise that resolves when the chart has been successfully saved to the specified path.
+ *
+ * @example
+ * ```ts
+ * // Save a simple dot plot as a PNG image.
+ * import { plot, dot } from "@observablehq/plot";
+ *
+ * const dataForPng = [{ year: 2024, value: 10 }, { year: 2025, value: 15 }];
+ * const chartForPng = (d) => plot({ marks: [dot(d, { x: "year", y: "value" })] });
+ * const pngPath = "output/dot-chart.png";
+ *
+ * await saveChart(dataForPng, chartForPng, pngPath);
+ * console.log(`Chart saved to ${pngPath}`);
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Save a bar chart as an SVG file with a custom background color.
+ * import { plot, barY } from "@observablehq/plot";
+ *
+ * const dataForSvg = [{ city: "New York", population: 8.4 }, { city: "Los Angeles", population: 3.9 }];
+ * const chartForSvg = (d) => plot({ marks: [barY(d, { x: "city", y: "population" })] });
+ * const svgPath = "output/bar-chart.svg";
+ *
+ * await saveChart(dataForSvg, chartForSvg, svgPath, { style: "background-color: #f0f0f0;" });
+ * console.log(`Chart saved to ${svgPath}`);
+ * ```
+ *
+ * @category Dataviz
+ */
+export default function saveChart(data: Iterable<any> | ArrayLike<any>, chart: (data: Iterable<any> | ArrayLike<any>) => SVGSVGElement | HTMLElement, path: string, options?: {
+    style?: string;
+    dark?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=saveChart.d.ts.map

package/script/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/saveChart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saveChart.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/saveChart.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAA8B,SAAS,CAErC,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,GAAG,CAAC,EAEpC,KAAK,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,GAAG,CAAC,KAAK,aAAa,GAAG,WAAW,EAC5E,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,GAC/C,OAAO,CAAC,IAAI,CAAC,CA+jBf"}