@nshiab/simple-data-analysis 5.19.8

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/printTable.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Prints a formatted table to the console with support for word wrapping within cells.
+ * Unlike console.table(), this function properly handles multi-line content within cells,
+ * making it ideal for displaying data with long text values.
+ *
+ * This function has been created for the [simple-data-analysis library](https://github.com/nshiab/simple-data-analysis), but can be used independently for any array of objects.
+ *
+ * @param data - An array of objects representing the rows of the table. Each object should have string keys.
+ * @param options - Optional configuration for table rendering.
+ * @param options.maxColumnWidth - The maximum width for any column (default: 75). Values exceeding this width will be wrapped at word boundaries.
+ * @param options.minColumnWidth - The minimum width for any column (default: 3).
+ * @param options.typesRowIndex - The index of a row that contains type annotations (e.g. "VARCHAR/string"). This row will be rendered in grey. If omitted, no row is treated as a types row.
+ * @returns void - The table is printed directly to the console.
+ *
+ * @example
+ * ```typescript
+ * const data = [
+ *   { name: "Alice", description: "A software engineer with expertise in TypeScript" },
+ *   { name: "Bob", description: "A product manager" }
+ * ];
+ * printTable(data, { maxColumnWidth: 30 });
+ * // Outputs a nicely formatted table with word-wrapped description column
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With types row
+ * const types = { name: "VARCHAR/string", age: "INTEGER/number" };
+ * const data = [
+ *   { name: "Alice", age: 30 },
+ *   { name: "Bob", age: 25 }
+ * ];
+ * printTable([types, ...data], { typesRowIndex: 0 });
+ * ```
+ */
+export default function printTable(data: {
+    [key: string]: unknown;
+}[], options?: {
+    maxColumnWidth?: number;
+    minColumnWidth?: number;
+    typesRowIndex?: number;
+}): void;
+//# sourceMappingURL=printTable.d.ts.map

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/printTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"printTable.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/printTable.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,IAAI,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAAE,EAClC,OAAO,CAAC,EAAE;IACR,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GACA,IAAI,CAuNN"}

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/printTable.js

@@ -0,0 +1,219 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = printTable;
+const wrapString_js_1 = __importDefault(require("./helpers/wrapString.js"));
+/**
+ * Prints a formatted table to the console with support for word wrapping within cells.
+ * Unlike console.table(), this function properly handles multi-line content within cells,
+ * making it ideal for displaying data with long text values.
+ *
+ * This function has been created for the [simple-data-analysis library](https://github.com/nshiab/simple-data-analysis), but can be used independently for any array of objects.
+ *
+ * @param data - An array of objects representing the rows of the table. Each object should have string keys.
+ * @param options - Optional configuration for table rendering.
+ * @param options.maxColumnWidth - The maximum width for any column (default: 75). Values exceeding this width will be wrapped at word boundaries.
+ * @param options.minColumnWidth - The minimum width for any column (default: 3).
+ * @param options.typesRowIndex - The index of a row that contains type annotations (e.g. "VARCHAR/string"). This row will be rendered in grey. If omitted, no row is treated as a types row.
+ * @returns void - The table is printed directly to the console.
+ *
+ * @example
+ * ```typescript
+ * const data = [
+ *   { name: "Alice", description: "A software engineer with expertise in TypeScript" },
+ *   { name: "Bob", description: "A product manager" }
+ * ];
+ * printTable(data, { maxColumnWidth: 30 });
+ * // Outputs a nicely formatted table with word-wrapped description column
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With types row
+ * const types = { name: "VARCHAR/string", age: "INTEGER/number" };
+ * const data = [
+ *   { name: "Alice", age: 30 },
+ *   { name: "Bob", age: 25 }
+ * ];
+ * printTable([types, ...data], { typesRowIndex: 0 });
+ * ```
+ */
+function printTable(data, options) {
+    if (!data || data.length === 0) {
+        console.log("(empty table)");
+        return;
+    }
+    const maxColumnWidth = options?.maxColumnWidth ?? 75;
+    const minColumnWidth = options?.minColumnWidth ?? 3;
+    // Helper function to format values for display
+    const formatValue = (value) => {
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        return String(value);
+    };
+    // Get all column names
+    const columns = Object.keys(data[0]);
+    if (columns.length === 0) {
+        console.log("(empty table)");
+        return;
+    }
+    // Single pass: calculate column widths and prepare wrapped data.
+    // First, seed widths from header names.
+    const columnWidths = {};
+    for (const col of columns) {
+        columnWidths[col] = col.length;
+    }
+    // Format every cell, track the longest raw line per column, and
+    // store the formatted strings for the wrapping step that follows.
+    const formattedData = [];
+    for (const row of data) {
+        const formattedRow = [];
+        for (let c = 0; c < columns.length; c++) {
+            const col = columns[c];
+            const value = formatValue(row[col]);
+            formattedRow.push(value);
+            // Track longest line (handles embedded newlines)
+            const lines = value.split("\n");
+            let longestLine = 0;
+            for (const line of lines) {
+                if (line.length > longestLine)
+                    longestLine = line.length;
+            }
+            if (longestLine > columnWidths[col]) {
+                columnWidths[col] = longestLine;
+            }
+        }
+        formattedData.push(formattedRow);
+    }
+    // Apply min/max constraints
+    for (const col of columns) {
+        columnWidths[col] = Math.min(Math.max(columnWidths[col], minColumnWidth), maxColumnWidth);
+    }
+    // Wrap pre-formatted strings into multi-line cells
+    const wrappedData = [];
+    for (let r = 0; r < formattedData.length; r++) {
+        const wrappedRow = {};
+        for (let c = 0; c < columns.length; c++) {
+            const col = columns[c];
+            const value = formattedData[r][c];
+            const width = columnWidths[col];
+            // Split by existing newlines, then wrap each part
+            const lines = value.split("\n");
+            const allWrappedLines = [];
+            for (const line of lines) {
+                if (line.length <= width) {
+                    allWrappedLines.push(line);
+                }
+                else {
+                    // Wrap long lines at word boundaries
+                    const wrapped = (0, wrapString_js_1.default)(line, width);
+                    allWrappedLines.push(...wrapped.split("\n"));
+                }
+            }
+            wrappedRow[col] = allWrappedLines.length > 0 ? allWrappedLines : [""];
+        }
+        wrappedData.push(wrappedRow);
+    }
+    // ANSI color codes (matching Deno's console colors)
+    const colors = {
+        reset: "\x1b[0m",
+        bold: "\x1b[1m",
+        grey: "\x1b[90m",
+        string: "\x1b[32m", // green
+        number: "\x1b[33m", // yellow
+        boolean: "\x1b[95m", // bright magenta/pink
+        date: "\x1b[36m", // cyan
+        null: "\x1b[90m", // grey
+    };
+    // Helper function to get color for a value based on its actual JavaScript type
+    const getColorForValue = (value, isTypeRow) => {
+        if (isTypeRow)
+            return colors.grey;
+        if (value === null || value === undefined)
+            return colors.null;
+        if (value instanceof Date)
+            return colors.date;
+        if (typeof value === "boolean")
+            return colors.boolean;
+        if (typeof value === "number")
+            return colors.number;
+        return colors.string;
+    };
+    // Helper function to create a horizontal border line with column junctions
+    const createBorderLine = (left, middle, right) => {
+        const segments = columns.map((col) => "─".repeat(columnWidths[col] + 2));
+        return colors.grey + left + segments.join(middle) + right + colors.reset;
+    };
+    // Helper function to create a separator line
+    const createSeparator = () => createBorderLine("├", "┼", "┤");
+    // Helper function to create the top border
+    const createTopBorder = () => createBorderLine("┌", "┬", "┐");
+    // Helper function to create the bottom border
+    const createBottomBorder = () => createBorderLine("└", "┴", "┘");
+    // Helper function to pad a string to a specific width
+    const pad = (str, width) => {
+        return str + " ".repeat(Math.max(0, width - str.length));
+    };
+    // Print top border
+    console.log(createTopBorder());
+    // Print header row (bold)
+    const headerParts = columns.map((col) => ` ${colors.bold}${pad(col, columnWidths[col])}${colors.reset} `);
+    console.log(colors.grey + "│" + colors.reset +
+        headerParts.join(colors.grey + "│" + colors.reset) + colors.grey + "│" +
+        colors.reset);
+    // Detect if any row has word wrapping (spans multiple lines)
+    let hasWordWrapping = false;
+    for (const wrappedRow of wrappedData) {
+        for (const col of columns) {
+            if (wrappedRow[col].length > 1) {
+                hasWordWrapping = true;
+                break;
+            }
+        }
+        if (hasWordWrapping)
+            break;
+    }
+    // Print separator after header (unless the first row is the types row,
+    // in which case the separator is printed after the types row instead)
+    if (options?.typesRowIndex !== 0) {
+        console.log(createSeparator());
+    }
+    // Print data rows
+    for (let i = 0; i < wrappedData.length; i++) {
+        const wrappedRow = wrappedData[i];
+        const originalRow = data[i];
+        const isTypeRow = i === options?.typesRowIndex;
+        // Find the maximum number of lines in this row
+        let maxLines = 1;
+        for (const col of columns) {
+            if (wrappedRow[col].length > maxLines) {
+                maxLines = wrappedRow[col].length;
+            }
+        }
+        // Print each line of this row
+        for (let lineIdx = 0; lineIdx < maxLines; lineIdx++) {
+            const lineParts = columns.map((col) => {
+                const lines = wrappedRow[col];
+                const lineValue = lineIdx < lines.length ? lines[lineIdx] : "";
+                const color = getColorForValue(originalRow[col], isTypeRow);
+                return ` ${color}${pad(lineValue, columnWidths[col])}${colors.reset} `;
+            });
+            console.log(colors.grey + "│" + colors.reset +
+                lineParts.join(colors.grey + "│" + colors.reset) + colors.grey +
+                "│" +
+                colors.reset);
+        }
+        // Print separator after types row
+        if (isTypeRow) {
+            console.log(createSeparator());
+        } // Print separator between rows when word wrapping is present (except after last row)
+        else if (hasWordWrapping && i < wrappedData.length - 1) {
+            console.log(createSeparator());
+        }
+    }
+    // Print bottom border
+    console.log(createBottomBorder());
+}

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/round.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Rounds a number based on specified criteria: a fixed number of decimal places, to the nearest integer multiple, or to a specific number of significant digits. This function provides flexible rounding capabilities essential for data presentation and numerical accuracy.
+ *
+ * By default, if no options are specified, the function rounds to the nearest whole number.
+ *
+ * @param number - The number to be rounded.
+ * @param options - An object containing options for rounding.
+ *   @param options.decimals - The number of decimal places to keep when rounding. For example, `round(123.456, { decimals: 2 })` returns `123.46`.
+ *   @param options.nearestInteger - The base to which the number should be rounded. For example, `round(123, { nearestInteger: 10 })` rounds to `120`.
+ *   @param options.significantDigits - The number of significant digits to retain. Significant digits are counted from the first non-zero digit. For example, `round(0.004622, { significantDigits: 1 })` rounds to `0.005`.
+ *   @param options.try - If `true`, the function will return `NaN` (Not a Number) if the input `number` is not a valid number, instead of throwing an error. Defaults to `false`.
+ * @returns The rounded number.
+ * @throws {Error} If the input `number` is not a number (and `options.try` is not `true`), or if more than one rounding option (`decimals`, `nearestInteger`, `significantDigits`) is provided.
+ *
+ * @example
+ * ```ts
+ * // Round to the nearest integer (default behavior).
+ * const resultDefault = round(1234.567);
+ * console.log(resultDefault); // Expected output: 1235
+ *
+ * // Round to one decimal place.
+ * const resultDecimal = round(1234.567, { decimals: 1 });
+ * console.log(resultDecimal); // Expected output: 1234.6
+ * ```
+ * @example
+ * ```ts
+ * // Round 123 to the nearest multiple of 10.
+ * const resultNearestInteger = round(123, { nearestInteger: 10 });
+ * console.log(resultNearestInteger); // Expected output: 120
+ *
+ * // Round 127 to the nearest multiple of 5.
+ * const resultNearestFive = round(127, { nearestInteger: 5 });
+ * console.log(resultNearestFive); // Expected output: 125
+ * ```
+ * @example
+ * ```ts
+ * // Round 0.004622 to 1 significant digit.
+ * const resultSignificantDigits = round(0.004622, { significantDigits: 1 });
+ * console.log(resultSignificantDigits); // Expected output: 0.005
+ *
+ * // Round 12345 to 2 significant digits.
+ * const resultSignificantDigitsLarge = round(12345, { significantDigits: 2 });
+ * console.log(resultSignificantDigitsLarge); // Expected output: 12000
+ * ```
+ * @example
+ * ```ts
+ * // Attempting to round a non-numeric value without `try: true` will throw an error.
+ * try {
+ *   round("abc");
+ * } catch (error) {
+ *   console.error("Error:", error.message);
+ *   // Expected output: "Error: abc is not a number. If you want to return NaN instead of throwing an error, pass option {try: true}."
+ * }
+ *
+ * // With `try: true`, it returns NaN for non-numeric input.
+ * const nanResult = round("abc", { try: true });
+ * console.log(nanResult); // Expected output: NaN
+ * ```
+ * @example
+ * ```ts
+ * // Providing multiple rounding options will throw an error.
+ * try {
+ *   round(123.45, { decimals: 1, significantDigits: 2 });
+ * } catch (error) {
+ *   console.error("Error:", error.message);
+ *   // Expected output: "Error: You can't use options decimals, nearestInteger, or significantDigits together. Pick one."
+ * }
+ * ```
+ * @category Formatting
+ */
+export default function round(number: number, options?: {
+    decimals?: number;
+    nearestInteger?: number;
+    significantDigits?: number;
+    try?: boolean;
+}): number;
+//# sourceMappingURL=round.d.ts.map

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/round.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"round.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/round.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AAEH,MAAM,CAAC,OAAO,UAAU,KAAK,CAC3B,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IACP,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,GAAG,CAAC,EAAE,OAAO,CAAC;CACV,GACL,MAAM,CAiCR"}

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/round.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * Rounds a number based on specified criteria: a fixed number of decimal places, to the nearest integer multiple, or to a specific number of significant digits. This function provides flexible rounding capabilities essential for data presentation and numerical accuracy.
+ *
+ * By default, if no options are specified, the function rounds to the nearest whole number.
+ *
+ * @param number - The number to be rounded.
+ * @param options - An object containing options for rounding.
+ *   @param options.decimals - The number of decimal places to keep when rounding. For example, `round(123.456, { decimals: 2 })` returns `123.46`.
+ *   @param options.nearestInteger - The base to which the number should be rounded. For example, `round(123, { nearestInteger: 10 })` rounds to `120`.
+ *   @param options.significantDigits - The number of significant digits to retain. Significant digits are counted from the first non-zero digit. For example, `round(0.004622, { significantDigits: 1 })` rounds to `0.005`.
+ *   @param options.try - If `true`, the function will return `NaN` (Not a Number) if the input `number` is not a valid number, instead of throwing an error. Defaults to `false`.
+ * @returns The rounded number.
+ * @throws {Error} If the input `number` is not a number (and `options.try` is not `true`), or if more than one rounding option (`decimals`, `nearestInteger`, `significantDigits`) is provided.
+ *
+ * @example
+ * ```ts
+ * // Round to the nearest integer (default behavior).
+ * const resultDefault = round(1234.567);
+ * console.log(resultDefault); // Expected output: 1235
+ *
+ * // Round to one decimal place.
+ * const resultDecimal = round(1234.567, { decimals: 1 });
+ * console.log(resultDecimal); // Expected output: 1234.6
+ * ```
+ * @example
+ * ```ts
+ * // Round 123 to the nearest multiple of 10.
+ * const resultNearestInteger = round(123, { nearestInteger: 10 });
+ * console.log(resultNearestInteger); // Expected output: 120
+ *
+ * // Round 127 to the nearest multiple of 5.
+ * const resultNearestFive = round(127, { nearestInteger: 5 });
+ * console.log(resultNearestFive); // Expected output: 125
+ * ```
+ * @example
+ * ```ts
+ * // Round 0.004622 to 1 significant digit.
+ * const resultSignificantDigits = round(0.004622, { significantDigits: 1 });
+ * console.log(resultSignificantDigits); // Expected output: 0.005
+ *
+ * // Round 12345 to 2 significant digits.
+ * const resultSignificantDigitsLarge = round(12345, { significantDigits: 2 });
+ * console.log(resultSignificantDigitsLarge); // Expected output: 12000
+ * ```
+ * @example
+ * ```ts
+ * // Attempting to round a non-numeric value without `try: true` will throw an error.
+ * try {
+ *   round("abc");
+ * } catch (error) {
+ *   console.error("Error:", error.message);
+ *   // Expected output: "Error: abc is not a number. If you want to return NaN instead of throwing an error, pass option {try: true}."
+ * }
+ *
+ * // With `try: true`, it returns NaN for non-numeric input.
+ * const nanResult = round("abc", { try: true });
+ * console.log(nanResult); // Expected output: NaN
+ * ```
+ * @example
+ * ```ts
+ * // Providing multiple rounding options will throw an error.
+ * try {
+ *   round(123.45, { decimals: 1, significantDigits: 2 });
+ * } catch (error) {
+ *   console.error("Error:", error.message);
+ *   // Expected output: "Error: You can't use options decimals, nearestInteger, or significantDigits together. Pick one."
+ * }
+ * ```
+ * @category Formatting
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = round;
+function round(number, options = {}) {
+    const optionsToCheck = [
+        options.decimals,
+        options.nearestInteger,
+        options.significantDigits,
+    ];
+    if (optionsToCheck.filter((d) => typeof d === "number").length > 1) {
+        throw new Error("You can't use options decimals, nearestInteger, or significantDigits together. Pick one.");
+    }
+    if (typeof number !== "number") {
+        if (options.try === true) {
+            return NaN;
+        }
+        else {
+            throw new Error(`${number} is not a number. If you want to return NaN instead of throwing an error, pass option {try: true}.`);
+        }
+    }
+    if (typeof options.decimals === "number") {
+        return parseFloat(number.toFixed(options.decimals));
+    }
+    else if (typeof options.nearestInteger === "number") {
+        return (Math.round(number / options.nearestInteger) * options.nearestInteger);
+    }
+    else if (typeof options.significantDigits === "number") {
+        return parseFloat(number.toPrecision(options.significantDigits));
+    }
+    else {
+        return Math.round(number);
+    }
+}

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/index.d.ts

@@ -0,0 +1,13 @@
+import formatDate from "./format/formatDate.js";
+import formatNumber from "./format/formatNumber.js";
+import round from "./format/round.js";
+import prettyDuration from "./format/prettyDuration.js";
+import arraysToData from "./format/arraysToData.js";
+import dataToArrays from "./format/dataToArrays.js";
+import dataAsCsv from "./format/dataAsCsv.js";
+import capitalize from "./format/capitalize.js";
+import camelCase from "./format/camelCase.js";
+import printTable from "./format/printTable.js";
+import normalizeString from "./format/normalizeString.js";
+export { arraysToData, camelCase, capitalize, dataAsCsv, dataToArrays, formatDate, formatNumber, normalizeString, prettyDuration, printTable, round, };
+//# sourceMappingURL=index.d.ts.map

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,wBAAwB,CAAC;AAChD,OAAO,YAAY,MAAM,0BAA0B,CAAC;AACpD,OAAO,KAAK,MAAM,mBAAmB,CAAC;AACtC,OAAO,cAAc,MAAM,4BAA4B,CAAC;AACxD,OAAO,YAAY,MAAM,0BAA0B,CAAC;AACpD,OAAO,YAAY,MAAM,0BAA0B,CAAC;AACpD,OAAO,SAAS,MAAM,uBAAuB,CAAC;AAC9C,OAAO,UAAU,MAAM,wBAAwB,CAAC;AAChD,OAAO,SAAS,MAAM,uBAAuB,CAAC;AAC9C,OAAO,UAAU,MAAM,wBAAwB,CAAC;AAChD,OAAO,eAAe,MAAM,6BAA6B,CAAC;AAE1D,OAAO,EACL,YAAY,EACZ,SAAS,EACT,UAAU,EACV,SAAS,EACT,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,cAAc,EACd,UAAU,EACV,KAAK,GACN,CAAC"}

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.round = exports.printTable = exports.prettyDuration = exports.normalizeString = exports.formatNumber = exports.formatDate = exports.dataToArrays = exports.dataAsCsv = exports.capitalize = exports.camelCase = exports.arraysToData = void 0;
+const formatDate_js_1 = __importDefault(require("./format/formatDate.js"));
+exports.formatDate = formatDate_js_1.default;
+const formatNumber_js_1 = __importDefault(require("./format/formatNumber.js"));
+exports.formatNumber = formatNumber_js_1.default;
+const round_js_1 = __importDefault(require("./format/round.js"));
+exports.round = round_js_1.default;
+const prettyDuration_js_1 = __importDefault(require("./format/prettyDuration.js"));
+exports.prettyDuration = prettyDuration_js_1.default;
+const arraysToData_js_1 = __importDefault(require("./format/arraysToData.js"));
+exports.arraysToData = arraysToData_js_1.default;
+const dataToArrays_js_1 = __importDefault(require("./format/dataToArrays.js"));
+exports.dataToArrays = dataToArrays_js_1.default;
+const dataAsCsv_js_1 = __importDefault(require("./format/dataAsCsv.js"));
+exports.dataAsCsv = dataAsCsv_js_1.default;
+const capitalize_js_1 = __importDefault(require("./format/capitalize.js"));
+exports.capitalize = capitalize_js_1.default;
+const camelCase_js_1 = __importDefault(require("./format/camelCase.js"));
+exports.camelCase = camelCase_js_1.default;
+const printTable_js_1 = __importDefault(require("./format/printTable.js"));
+exports.printTable = printTable_js_1.default;
+const normalizeString_js_1 = __importDefault(require("./format/normalizeString.js"));
+exports.normalizeString = normalizeString_js_1.default;

package/script/deps/jsr.io/@nshiab/journalism-google/1.0.6/src/google/addSheetRows.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Appends new rows of data to an existing Google Sheet. This function is useful for continuously adding new records to a spreadsheet without overwriting existing data, such as logging events, collecting form submissions, or appending new data points to a time series.
+ *
+ * The function expects the data to be an array of objects, where the keys of these objects correspond to the column headers in your Google Sheet.
+ *
+ * By default, authentication is handled via environment variables (`GOOGLE_PRIVATE_KEY` and `GOOGLE_SERVICE_ACCOUNT_EMAIL`). Alternatively, you can use `GOOGLE_APPLICATION_CREDENTIALS` pointing to a service account JSON file. For detailed setup instructions, refer to the `node-google-spreadsheet` authentication guide: [https://theoephraim.github.io/node-google-spreadsheet/#/guides/authentication](https://theoephraim.github.io/node-google-spreadsheet/#/guides/authentication).
+ *
+ * @param data - An array of objects, where each object represents a row to be appended to the sheet. The keys of the objects should match the existing column headers in the sheet.
+ * @param sheetUrl - The URL of the Google Sheet to which rows will be appended. This URL should point to a specific sheet (e.g., ending with `#gid=0`).
+ * @param options - An optional object with configuration options:
+ *   @param options.headerIndex - The 0-based index of the row that contains the headers in your sheet. By default, the first row (index 0) is considered the header. Use this if your headers are in a different row.
+ *   @param options.raw - If `true`, data will be written as raw values, preventing Google Sheets from automatically guessing data types or applying formatting. This can be useful for preserving exact string representations. Defaults to `false`.
+ *   @param options.apiEmail - Optional. Your Google Service Account email. If provided, this will override the `process.env.GOOGLE_SERVICE_ACCOUNT_EMAIL` environment variable.
+ *   @param options.apiKey - Optional. Your Google Service Account private key. If provided, this will override the `process.env.GOOGLE_PRIVATE_KEY` environment variable.
+ * @returns A Promise that resolves when the rows have been successfully appended to the sheet.
+ *
+ * @example
+ * ```ts
+ * // The data needs to be an array of objects. The keys of the objects must match the sheet's columns.
+ * const data = [
+ *   { first: "Nael", last: "Shiab" },
+ *   { first: "Andrew", last: "Ryan" }
+ * ];
+ *
+ * // Fake URL used as an example.
+ * const sheetUrl = "https://docs.google.com/spreadsheets/d/nrqo3oP4KMWYbELScQa8W1nHZPfIrA7LIz9UmcRE4GyJN/edit#gid=0";
+ *
+ * // Appending the new rows to the sheet.
+ * await addSheetRows(data, sheetUrl);
+ * console.log("Rows added successfully.");
+ * ```
+ * @example
+ * ```ts
+ * // Append data as raw values to prevent Google Sheets from interpreting them.
+ * const rawData = [
+ *   { product_id: '001', quantity: '05' }, // '05' might be interpreted as 5 without raw: true
+ *   { product_id: '002', quantity: '10' }
+ * ];
+ * await addSheetRows(rawData, sheetUrl, { raw: true });
+ * console.log("Raw rows added successfully.");
+ * ```
+ * @example
+ * ```ts
+ * // If your sheet's headers are on the second row (index 1).
+ * const dataWithHeaderIndex = [
+ *   { Name: "John Doe", Age: 30 }
+ * ];
+ * await addSheetRows(dataWithHeaderIndex, sheetUrl, { headerIndex: 1 });
+ * console.log("Rows added with custom header index.");
+ * ```
+ * @example
+ * ```ts
+ * // Use explicitly provided API credentials instead of environment variables.
+ * await addSheetRows(data, sheetUrl, {
+ *   apiEmail: "your-service-account@project-id.iam.gserviceaccount.com",
+ *   apiKey: "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n"
+ * });
+ * console.log("Rows added using custom API credentials.");
+ * ```
+ * @category Google
+ */
+export default function addSheetRows(data: {
+    [key: string]: string | number | boolean | Date | null;
+}[], sheetUrl: string, options?: {
+    headerIndex?: number;
+    raw?: boolean;
+    apiEmail?: string;
+    apiKey?: string;
+}): Promise<void>;
+//# sourceMappingURL=addSheetRows.d.ts.map

package/script/deps/jsr.io/@nshiab/journalism-google/1.0.6/src/google/addSheetRows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addSheetRows.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/journalism-google/1.0.6/src/google/addSheetRows.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wBAA8B,YAAY,CACxC,IAAI,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,IAAI,CAAA;CAAE,EAAE,EAClE,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE;IACP,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACZ,GACL,OAAO,CAAC,IAAI,CAAC,CAQf"}

package/script/deps/jsr.io/@nshiab/journalism-google/1.0.6/src/google/addSheetRows.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = addSheetRows;
+const cleanData_js_1 = __importDefault(require("./helpers/cleanData.js"));
+const logToSheet_js_1 = __importDefault(require("./helpers/logToSheet.js"));
+/**
+ * Appends new rows of data to an existing Google Sheet. This function is useful for continuously adding new records to a spreadsheet without overwriting existing data, such as logging events, collecting form submissions, or appending new data points to a time series.
+ *
+ * The function expects the data to be an array of objects, where the keys of these objects correspond to the column headers in your Google Sheet.
+ *
+ * By default, authentication is handled via environment variables (`GOOGLE_PRIVATE_KEY` and `GOOGLE_SERVICE_ACCOUNT_EMAIL`). Alternatively, you can use `GOOGLE_APPLICATION_CREDENTIALS` pointing to a service account JSON file. For detailed setup instructions, refer to the `node-google-spreadsheet` authentication guide: [https://theoephraim.github.io/node-google-spreadsheet/#/guides/authentication](https://theoephraim.github.io/node-google-spreadsheet/#/guides/authentication).
+ *
+ * @param data - An array of objects, where each object represents a row to be appended to the sheet. The keys of the objects should match the existing column headers in the sheet.
+ * @param sheetUrl - The URL of the Google Sheet to which rows will be appended. This URL should point to a specific sheet (e.g., ending with `#gid=0`).
+ * @param options - An optional object with configuration options:
+ *   @param options.headerIndex - The 0-based index of the row that contains the headers in your sheet. By default, the first row (index 0) is considered the header. Use this if your headers are in a different row.
+ *   @param options.raw - If `true`, data will be written as raw values, preventing Google Sheets from automatically guessing data types or applying formatting. This can be useful for preserving exact string representations. Defaults to `false`.
+ *   @param options.apiEmail - Optional. Your Google Service Account email. If provided, this will override the `process.env.GOOGLE_SERVICE_ACCOUNT_EMAIL` environment variable.
+ *   @param options.apiKey - Optional. Your Google Service Account private key. If provided, this will override the `process.env.GOOGLE_PRIVATE_KEY` environment variable.
+ * @returns A Promise that resolves when the rows have been successfully appended to the sheet.
+ *
+ * @example
+ * ```ts
+ * // The data needs to be an array of objects. The keys of the objects must match the sheet's columns.
+ * const data = [
+ *   { first: "Nael", last: "Shiab" },
+ *   { first: "Andrew", last: "Ryan" }
+ * ];
+ *
+ * // Fake URL used as an example.
+ * const sheetUrl = "https://docs.google.com/spreadsheets/d/nrqo3oP4KMWYbELScQa8W1nHZPfIrA7LIz9UmcRE4GyJN/edit#gid=0";
+ *
+ * // Appending the new rows to the sheet.
+ * await addSheetRows(data, sheetUrl);
+ * console.log("Rows added successfully.");
+ * ```
+ * @example
+ * ```ts
+ * // Append data as raw values to prevent Google Sheets from interpreting them.
+ * const rawData = [
+ *   { product_id: '001', quantity: '05' }, // '05' might be interpreted as 5 without raw: true
+ *   { product_id: '002', quantity: '10' }
+ * ];
+ * await addSheetRows(rawData, sheetUrl, { raw: true });
+ * console.log("Raw rows added successfully.");
+ * ```
+ * @example
+ * ```ts
+ * // If your sheet's headers are on the second row (index 1).
+ * const dataWithHeaderIndex = [
+ *   { Name: "John Doe", Age: 30 }
+ * ];
+ * await addSheetRows(dataWithHeaderIndex, sheetUrl, { headerIndex: 1 });
+ * console.log("Rows added with custom header index.");
+ * ```
+ * @example
+ * ```ts
+ * // Use explicitly provided API credentials instead of environment variables.
+ * await addSheetRows(data, sheetUrl, {
+ *   apiEmail: "your-service-account@project-id.iam.gserviceaccount.com",
+ *   apiKey: "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n"
+ * });
+ * console.log("Rows added using custom API credentials.");
+ * ```
+ * @category Google
+ */
+async function addSheetRows(data, sheetUrl, options = {}) {
+    const sheet = await (0, logToSheet_js_1.default)(sheetUrl, options);
+    const headerRow = Object.keys(data[0]);
+    await sheet.setHeaderRow(headerRow, typeof options.headerIndex === "number" ? options.headerIndex + 1 : 1);
+    await sheet.addRows((0, cleanData_js_1.default)(data), { raw: options.raw });
+}