@copado/agentia-cli 0.122.0-alpha.1 → 1.0.0-beta.0

package/dist/lib/testing-data-core.js

@@ -1,208 +1,20 @@
-export const TESTING_DATA_MAX_EXPANDED_RUNS = 100;
-export const TESTING_DATA_MAX_ROWS = 10_000;
-export const TESTING_DATA_MAX_COLUMNS = 1000;
-export const TESTING_DATA_MAX_CELLS = 100_000;
-export const TESTING_DATA_MAX_CELL_BYTES = 64 * 1024;
-const KNOWN_HEADERS = new Set(['*** Test Cases ***', '[Documentation]', '[Tags]']);
-export function normalizeTestingDataTable(value) {
-    const record = unwrapRecord(value);
-    const { version } = record;
-    return {
-        ...record,
-        ...(version === undefined || version === null ? {} : { version: String(version) }),
-        ...(Array.isArray(record.data) ? { data: coerceTestingDataMatrix(record.data) } : {}),
-    };
-}
-export function normalizeTestingDataTables(value) {
-    const unwrapped = unwrapValue(value);
-    const records = Array.isArray(unwrapped)
-        ? unwrapped
-        : isRecord(unwrapped) && Array.isArray(unwrapped.data) && unwrapped.data.every((item) => isRecord(item))
-            ? unwrapped.data
-            : isRecord(unwrapped) && Array.isArray(unwrapped.items)
-                ? unwrapped.items
-                : [];
-    return records.filter((item) => isRecord(item)).map((record) => normalizeTestingDataTable(record));
-}
-export function coerceTestingDataMatrix(value) {
-    if (!Array.isArray(value) || !value.every((row) => Array.isArray(row))) {
-        throw new Error('Data-table input must be a JSON array of row arrays.');
-    }
-    const matrix = value.map((row) => row.map((cell) => {
-        if (cell === null || cell === undefined)
-            return '';
-        if (typeof cell === 'string')
-            return cell;
-        return typeof cell === 'object' ? JSON.stringify(cell) : String(cell);
-    }));
-    validateTestingDataMatrix(matrix);
-    return matrix;
-}
-export function prepareTestingData(matrix, orientation) {
-    validateTestingDataMatrix(matrix);
-    const data = orientation === 'column' ? transposeTestingData(matrix) : matrix.map((row) => [...row]);
-    validateTestingDataMatrix(data);
-    const header = data[0];
-    if (header === undefined)
-        return data;
-    data[0] = header.map((cell) => (KNOWN_HEADERS.has(cell) || isRobotVariable(cell) ? cell : `\${${cell}}`));
-    return data;
-}
-export function validateTestingDataMatrix(matrix) {
-    if (matrix.length > TESTING_DATA_MAX_ROWS) {
-        throw new Error(`Data-table input exceeds the ${TESTING_DATA_MAX_ROWS} row safety limit.`);
-    }
-    let cells = 0;
-    for (const row of matrix) {
-        if (row.length > TESTING_DATA_MAX_COLUMNS) {
-            throw new Error(`Data-table input exceeds the ${TESTING_DATA_MAX_COLUMNS} column safety limit.`);
-        }
-        cells += row.length;
-        if (cells > TESTING_DATA_MAX_CELLS) {
-            throw new Error(`Data-table input exceeds the ${TESTING_DATA_MAX_CELLS} cell safety limit.`);
-        }
-        for (const cell of row) {
-            if (Buffer.byteLength(cell) > TESTING_DATA_MAX_CELL_BYTES) {
-                throw new Error(`Data-table cell exceeds the ${TESTING_DATA_MAX_CELL_BYTES} byte safety limit.`);
-            }
-        }
-    }
-}
-export function unwrapTestingDataHeaders(matrix) {
-    const data = matrix.map((row) => [...row]);
-    if (data[0] !== undefined)
-        data[0] = data[0].map((cell) => stripTestingDataTablePrefix(cell));
-    return data;
-}
-export function transposeTestingData(matrix) {
-    if (matrix.length === 0)
-        return [];
-    const width = Math.max(...matrix.map((row) => row.length), 0);
-    return Array.from({ length: width }, (_, column) => matrix.map((row) => row[column] ?? ''));
-}
-export function stripTestingDataTablePrefix(value) {
-    if (KNOWN_HEADERS.has(value))
-        return value;
-    const clean = value.startsWith('${') && value.endsWith('}') ? value.slice(2, -1) : value;
-    const separator = clean.indexOf('.');
-    return separator > 0 ? clean.slice(separator + 1) : clean;
-}
-export function formatTestingDatasetKey(header, tableName) {
-    if (KNOWN_HEADERS.has(header))
-        return header;
-    const variable = stripTestingDataTablePrefix(header);
-    return tableName.length === 0 ? variable : `${tableName}.${variable}`;
-}
-export function parseTestingDatasetSelector(raw) {
-    const indices = [];
-    for (const rawPart of raw.split(',')) {
-        const part = rawPart.trim();
-        if (part.length === 0)
-            continue;
-        const range = part.split('-');
-        if (range.length > 2)
-            throw new Error(`Invalid dataset selector: ${part}.`);
-        const start = positiveInteger(range[0] ?? '', 'dataset index');
-        const end = range.length === 2 ? positiveInteger(range[1] ?? '', 'dataset index') : start;
-        if (start > end)
-            throw new Error(`Invalid dataset range ${part}: start must not exceed end.`);
-        if (end - start + 1 > TESTING_DATA_MAX_EXPANDED_RUNS) {
-            throw new Error(`Dataset selector exceeds the ${TESTING_DATA_MAX_EXPANDED_RUNS} run safety limit.`);
-        }
-        for (let index = start; index <= end; index++)
-            indices.push(index);
-    }
-    const result = [...new Set(indices)].sort((left, right) => left - right);
-    if (result.length === 0)
-        throw new Error('Dataset selector must include at least one 1-based index.');
-    if (result.length > TESTING_DATA_MAX_EXPANDED_RUNS) {
-        throw new Error(`Dataset selector exceeds the ${TESTING_DATA_MAX_EXPANDED_RUNS} run safety limit.`);
-    }
-    return result;
-}
-export function parseTestingDataTableRunSpecs(values) {
-    if (values === undefined || values.length === 0)
-        return [];
-    const selections = [];
-    const seen = new Set();
-    for (const value of values) {
-        for (const rawSection of value.split(';')) {
-            const section = rawSection.trim();
-            if (section.length === 0)
-                continue;
-            const separator = section.indexOf(':');
-            if (separator === -1)
-                throw new Error(`Data-table selection "${section}" must use TABLE_ID:DATASETS.`);
-            const tableId = positiveInteger(section.slice(0, separator), 'data-table ID');
-            if (seen.has(tableId))
-                throw new Error(`Data-table ID ${tableId} is selected more than once.`);
-            const datasets = parseTestingDatasetSelector(section.slice(separator + 1));
-            seen.add(tableId);
-            selections.push({ datasets, tableId });
-        }
-    }
-    if (selections.length === 0)
-        throw new Error('--datatable requires at least one TABLE_ID:DATASETS selection.');
-    const runCount = selections[0]?.datasets.length ?? 0;
-    const mismatch = selections.find((selection) => selection.datasets.length !== runCount);
-    if (mismatch !== undefined) {
-        throw new Error(`All data tables must select the same number of datasets; table ${mismatch.tableId} does not.`);
-    }
-    if (runCount > TESTING_DATA_MAX_EXPANDED_RUNS) {
-        throw new Error(`Data-driven runs are limited to ${TESTING_DATA_MAX_EXPANDED_RUNS} builds per command.`);
-    }
-    return selections;
-}
-export function sliceTestingDataTable(table, datasets) {
-    const { data } = table;
-    if (data === undefined || data.length === 0)
-        return { ...table, data: [] };
-    const available = data.length - 1;
-    const invalid = datasets.find((index) => index > available);
-    if (invalid !== undefined) {
-        throw new Error(`Data table ${table.id ?? table.name ?? ''} has ${available} dataset(s); dataset ${invalid} does not exist.`);
-    }
-    return { ...table, data: [data[0] ?? [], ...datasets.map((index) => data[index] ?? [])] };
-}
-export function buildTestingDataDisplayGrid(table) {
-    const data = table.data ?? [];
-    if (data.length === 0)
-        return { headers: [], rows: [] };
-    const variables = data[0] ?? [];
-    const datasets = data.slice(1);
-    const headers = ['Key', ...datasets.map((_, index) => `Data Set ${String(index + 1).padStart(2, '0')}`)];
-    const rows = variables.map((variable, index) => [
-        stripTestingDataTablePrefix(variable),
-        ...datasets.map((dataset) => dataset[index] ?? ''),
-    ]);
-    return { headers, rows };
-}
-function positiveInteger(raw, label) {
-    const value = raw.trim();
-    if (!/^\d+$/u.test(value))
-        throw new Error(`Invalid ${label}: ${raw.trim() || '(empty)'}.`);
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isSafeInteger(parsed) || parsed <= 0)
-        throw new Error(`${label} must be a positive 1-based integer.`);
-    return parsed;
-}
-function isRobotVariable(value) {
-    return /^[$@&]\{.*\}$/u.test(value);
-}
-function unwrapValue(value) {
-    if (!isRecord(value))
-        return value;
-    if ('data' in value && !Array.isArray(value.data))
-        return unwrapValue(value.data);
-    if ('result' in value)
-        return unwrapValue(value.result);
-    return value;
-}
-function unwrapRecord(value) {
-    const unwrapped = unwrapValue(value);
-    return isRecord(unwrapped) ? unwrapped : {};
-}
-function isRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-//# sourceMappingURL=testing-data-core.js.map
+import {modules} from './runtime.js';
+const TESTING_DATA_MAX_CELLS = modules["testing-data-core.js"]["TESTING_DATA_MAX_CELLS"]
+const TESTING_DATA_MAX_CELL_BYTES = modules["testing-data-core.js"]["TESTING_DATA_MAX_CELL_BYTES"]
+const TESTING_DATA_MAX_COLUMNS = modules["testing-data-core.js"]["TESTING_DATA_MAX_COLUMNS"]
+const TESTING_DATA_MAX_EXPANDED_RUNS = modules["testing-data-core.js"]["TESTING_DATA_MAX_EXPANDED_RUNS"]
+const TESTING_DATA_MAX_ROWS = modules["testing-data-core.js"]["TESTING_DATA_MAX_ROWS"]
+const buildTestingDataDisplayGrid = modules["testing-data-core.js"]["buildTestingDataDisplayGrid"]
+const coerceTestingDataMatrix = modules["testing-data-core.js"]["coerceTestingDataMatrix"]
+const formatTestingDatasetKey = modules["testing-data-core.js"]["formatTestingDatasetKey"]
+const normalizeTestingDataTable = modules["testing-data-core.js"]["normalizeTestingDataTable"]
+const normalizeTestingDataTables = modules["testing-data-core.js"]["normalizeTestingDataTables"]
+const parseTestingDataTableRunSpecs = modules["testing-data-core.js"]["parseTestingDataTableRunSpecs"]
+const parseTestingDatasetSelector = modules["testing-data-core.js"]["parseTestingDatasetSelector"]
+const prepareTestingData = modules["testing-data-core.js"]["prepareTestingData"]
+const sliceTestingDataTable = modules["testing-data-core.js"]["sliceTestingDataTable"]
+const stripTestingDataTablePrefix = modules["testing-data-core.js"]["stripTestingDataTablePrefix"]
+const transposeTestingData = modules["testing-data-core.js"]["transposeTestingData"]
+const unwrapTestingDataHeaders = modules["testing-data-core.js"]["unwrapTestingDataHeaders"]
+const validateTestingDataMatrix = modules["testing-data-core.js"]["validateTestingDataMatrix"]
+export {TESTING_DATA_MAX_CELLS, TESTING_DATA_MAX_CELL_BYTES, TESTING_DATA_MAX_COLUMNS, TESTING_DATA_MAX_EXPANDED_RUNS, TESTING_DATA_MAX_ROWS, buildTestingDataDisplayGrid, coerceTestingDataMatrix, formatTestingDatasetKey, normalizeTestingDataTable, normalizeTestingDataTables, parseTestingDataTableRunSpecs, parseTestingDatasetSelector, prepareTestingData, sliceTestingDataTable, stripTestingDataTablePrefix, transposeTestingData, unwrapTestingDataHeaders, validateTestingDataMatrix};

package/dist/lib/testing-data-export.js

@@ -1,2 +1,6 @@
-export { normalizeTestingDataPath, resolveTestingDataExportFormat, serializeDelimitedTestingData, writeTestingDataFile, } from './testing-data-io.js';
-//# sourceMappingURL=testing-data-export.js.map
+import {modules} from './runtime.js';
+const normalizeTestingDataPath = modules["testing-data-export.js"]["normalizeTestingDataPath"]
+const resolveTestingDataExportFormat = modules["testing-data-export.js"]["resolveTestingDataExportFormat"]
+const serializeDelimitedTestingData = modules["testing-data-export.js"]["serializeDelimitedTestingData"]
+const writeTestingDataFile = modules["testing-data-export.js"]["writeTestingDataFile"]
+export {normalizeTestingDataPath, resolveTestingDataExportFormat, serializeDelimitedTestingData, writeTestingDataFile};

package/dist/lib/testing-data-import.js

@@ -1,2 +1,6 @@
-export { parseDelimitedTestingData, parseTestingDataText, readTestingDataFile, readTestingDataInput, } from './testing-data-io.js';
-//# sourceMappingURL=testing-data-import.js.map
+import {modules} from './runtime.js';
+const parseDelimitedTestingData = modules["testing-data-import.js"]["parseDelimitedTestingData"]
+const parseTestingDataText = modules["testing-data-import.js"]["parseTestingDataText"]
+const readTestingDataFile = modules["testing-data-import.js"]["readTestingDataFile"]
+const readTestingDataInput = modules["testing-data-import.js"]["readTestingDataInput"]
+export {parseDelimitedTestingData, parseTestingDataText, readTestingDataFile, readTestingDataInput};

package/dist/lib/testing-data-io.js

@@ -1,236 +1,12 @@
-import ExcelJS from 'exceljs';
-import { existsSync, statSync } from 'node:fs';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { dirname, extname, resolve } from 'node:path';
-import { coerceTestingDataMatrix, validateTestingDataMatrix, } from './testing-data-core.js';
-export const TESTING_DATA_MAX_INPUT_BYTES = 10 * 1024 * 1024;
-export const TESTING_DATA_MAX_XLSX_EXPANDED_BYTES = 50 * 1024 * 1024;
-const TESTING_DATA_MAX_XLSX_ENTRIES = 10_000;
-export async function readTestingDataInput(input) {
-    const sourceCount = [input.file !== undefined, input.jsonData !== undefined, input.stdin === true].filter(Boolean).length;
-    if (sourceCount !== 1)
-        throw new Error('Provide exactly one data source: --file, --json-data, or --stdin.');
-    if (input.file !== undefined)
-        return readTestingDataFile(input.file);
-    const text = input.jsonData ?? await readBoundedTestingDataStream(process.stdin);
-    return parseTestingDataText(text, input.jsonData !== undefined || text.trimStart().startsWith('[') ? 'json' : undefined);
-}
-export async function readTestingDataFile(path) {
-    const target = normalizeTestingDataPath(path, 'input');
-    const extension = extname(target).toLowerCase();
-    if (extension === '.xls' || extension === '.ods') {
-        throw new Error(`The ${extension} format is not supported. Save the file as .xlsx, .csv, or .tsv.`);
-    }
-    if (!existsSync(target))
-        throw new Error(`Data-table input file not found: ${path}`);
-    const stat = statSync(target);
-    if (!stat.isFile())
-        throw new Error(`Data-table input path must be a file: ${path}`);
-    if (stat.size > TESTING_DATA_MAX_INPUT_BYTES) {
-        throw new Error(`Data-table input exceeds the ${TESTING_DATA_MAX_INPUT_BYTES} byte safety limit.`);
-    }
-    if (extension === '.xlsx') {
-        try {
-            const input = await readFile(target);
-            validateTestingXlsxArchive(input);
-            const workbook = new ExcelJS.Workbook();
-            await workbook.xlsx.load(input);
-            const sheet = workbook.worksheets[0];
-            if (sheet === undefined)
-                throw new Error('missing sheet');
-            const matrix = [];
-            sheet.eachRow({ includeEmpty: true }, (row) => {
-                const values = [];
-                for (let column = 1; column <= sheet.columnCount; column++)
-                    values.push(row.getCell(column).text);
-                matrix.push(values);
-            });
-            validateTestingDataMatrix(matrix);
-            return matrix;
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.startsWith('Data-table'))
-                throw error;
-            throw new Error(`${path} is not a valid XLSX file.`);
-        }
-    }
-    if (extension === '.json')
-        return parseTestingDataText(await readFile(target, 'utf8'), 'json');
-    if (extension === '.tsv')
-        return parseTestingDataText(await readFile(target, 'utf8'), 'tsv');
-    if (extension === '.csv' || extension === '.txt')
-        return parseTestingDataText(await readFile(target, 'utf8'), 'csv');
-    throw new Error('Unsupported data-table input format. Use CSV, TSV, JSON, or XLSX; XLS and ODS are not supported.');
-}
-function validateTestingXlsxArchive(input) {
-    const minimumEocdOffset = Math.max(0, input.length - 65_557);
-    let eocdOffset = -1;
-    for (let offset = input.length - 22; offset >= minimumEocdOffset; offset--) {
-        if (input.readUInt32LE(offset) === 0x06_05_4B_50) {
-            eocdOffset = offset;
-            break;
-        }
-    }
-    if (eocdOffset < 0)
-        throw new Error('invalid XLSX archive directory');
-    const entryCount = input.readUInt16LE(eocdOffset + 10);
-    const directorySize = input.readUInt32LE(eocdOffset + 12);
-    const directoryOffset = input.readUInt32LE(eocdOffset + 16);
-    if (entryCount > TESTING_DATA_MAX_XLSX_ENTRIES ||
-        directoryOffset + directorySize > input.length) {
-        throw new Error(`Data-table XLSX exceeds the ${TESTING_DATA_MAX_XLSX_ENTRIES} entry safety limit.`);
-    }
-    let expandedBytes = 0;
-    let offset = directoryOffset;
-    for (let entry = 0; entry < entryCount; entry++) {
-        if (offset + 46 > input.length || input.readUInt32LE(offset) !== 0x02_01_4B_50) {
-            throw new Error('invalid XLSX archive directory');
-        }
-        const expandedEntryBytes = input.readUInt32LE(offset + 24);
-        if (expandedEntryBytes === 0xFF_FF_FF_FF)
-            throw new Error('ZIP64 XLSX inputs are not supported.');
-        expandedBytes += expandedEntryBytes;
-        if (expandedBytes > TESTING_DATA_MAX_XLSX_EXPANDED_BYTES) {
-            throw new Error(`Data-table XLSX exceeds the ${TESTING_DATA_MAX_XLSX_EXPANDED_BYTES} expanded byte safety limit.`);
-        }
-        offset +=
-            46 +
-                input.readUInt16LE(offset + 28) +
-                input.readUInt16LE(offset + 30) +
-                input.readUInt16LE(offset + 32);
-    }
-}
-export function parseTestingDataText(text, format) {
-    if (Buffer.byteLength(text) > TESTING_DATA_MAX_INPUT_BYTES) {
-        throw new Error(`Data-table input exceeds the ${TESTING_DATA_MAX_INPUT_BYTES} byte safety limit.`);
-    }
-    if (format === 'json') {
-        try {
-            return coerceTestingDataMatrix(JSON.parse(text));
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.startsWith('Data-table input'))
-                throw error;
-            throw new Error('Data-table JSON must be a valid array of row arrays.');
-        }
-    }
-    const delimiter = format === 'tsv' ? '\t' : format === 'csv' ? ',' : detectTestingDataDelimiter(text);
-    return parseDelimitedTestingData(text, delimiter);
-}
-export function parseDelimitedTestingData(text, delimiter) {
-    const rows = [];
-    let row = [];
-    let cell = '';
-    let quoted = false;
-    for (let index = 0; index < text.length; index++) {
-        const character = text[index];
-        if (quoted) {
-            if (character === '"' && text[index + 1] === '"') {
-                cell += '"';
-                index++;
-            }
-            else if (character === '"') {
-                quoted = false;
-            }
-            else {
-                cell += character;
-            }
-        }
-        else if (character === '"' && cell.length === 0) {
-            quoted = true;
-        }
-        else if (character === delimiter) {
-            row.push(cell);
-            cell = '';
-        }
-        else if (character === '\n' || character === '\r') {
-            if (character === '\r' && text[index + 1] === '\n')
-                index++;
-            row.push(cell);
-            rows.push(row);
-            row = [];
-            cell = '';
-        }
-        else {
-            cell += character;
-        }
-    }
-    if (quoted)
-        throw new Error('Data-table delimited input contains an unterminated quoted cell.');
-    if (cell.length > 0 || row.length > 0) {
-        row.push(cell);
-        rows.push(row);
-    }
-    return rows;
-}
-async function readBoundedTestingDataStream(stream) {
-    const chunks = [];
-    let size = 0;
-    for await (const chunk of stream) {
-        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        size += bytes.length;
-        if (size > TESTING_DATA_MAX_INPUT_BYTES) {
-            throw new Error(`Data-table input exceeds the ${TESTING_DATA_MAX_INPUT_BYTES} byte safety limit.`);
-        }
-        chunks.push(bytes);
-    }
-    return Buffer.concat(chunks).toString('utf8');
-}
-export function serializeDelimitedTestingData(matrix, delimiter) {
-    return `${matrix
-        .map((row) => row
-        .map((cell) => {
-        const escaped = cell.replaceAll('"', '""');
-        return cell.includes(delimiter) || /["\r\n]/u.test(cell) ? `"${escaped}"` : escaped;
-    })
-        .join(delimiter))
-        .join('\n')}\n`;
-}
-export async function writeTestingDataFile(path, matrix, explicitFormat) {
-    const output = normalizeTestingDataPath(path, 'output');
-    const format = resolveTestingDataExportFormat(output, explicitFormat);
-    await mkdir(dirname(output), { recursive: true });
-    if (format === 'xlsx') {
-        const workbook = new ExcelJS.Workbook();
-        const sheet = workbook.addWorksheet('Data');
-        for (const row of matrix)
-            sheet.addRow(row);
-        await workbook.xlsx.writeFile(output);
-    }
-    else {
-        await writeFile(output, serializeDelimitedTestingData(matrix, format === 'tsv' ? '\t' : ','), 'utf8');
-    }
-    return { format, output, rows: matrix.length };
-}
-export function resolveTestingDataExportFormat(path, explicitFormat) {
-    if (explicitFormat !== undefined)
-        return explicitFormat;
-    const extension = extname(path).toLowerCase();
-    if (extension === '.csv' || extension === '.txt')
-        return 'csv';
-    if (extension === '.tsv')
-        return 'tsv';
-    if (extension === '.xlsx')
-        return 'xlsx';
-    if (extension === '.xls' || extension === '.ods') {
-        throw new Error(`The ${extension} format cannot be exported. Use .xlsx, .csv, or .tsv.`);
-    }
-    throw new Error('Cannot determine export format. Use --format csv|tsv|xlsx or a matching file extension.');
-}
-export function normalizeTestingDataPath(path, label) {
-    if (path.trim().length === 0 || path.includes('\0'))
-        throw new Error(`Data-table ${label} path must not be empty.`);
-    const target = resolve(path);
-    if (label === 'output' && existsSync(target) && statSync(target).isDirectory()) {
-        throw new Error(`Data-table output path must be a file: ${path}`);
-    }
-    return target;
-}
-function detectTestingDataDelimiter(text) {
-    const sample = text.slice(0, 4096);
-    return [...sample].filter((character) => character === '\t').length >
-        [...sample].filter((character) => character === ',').length
-        ? '\t'
-        : ',';
-}
-//# sourceMappingURL=testing-data-io.js.map
+import {modules} from './runtime.js';
+const TESTING_DATA_MAX_INPUT_BYTES = modules["testing-data-io.js"]["TESTING_DATA_MAX_INPUT_BYTES"]
+const TESTING_DATA_MAX_XLSX_EXPANDED_BYTES = modules["testing-data-io.js"]["TESTING_DATA_MAX_XLSX_EXPANDED_BYTES"]
+const normalizeTestingDataPath = modules["testing-data-io.js"]["normalizeTestingDataPath"]
+const parseDelimitedTestingData = modules["testing-data-io.js"]["parseDelimitedTestingData"]
+const parseTestingDataText = modules["testing-data-io.js"]["parseTestingDataText"]
+const readTestingDataFile = modules["testing-data-io.js"]["readTestingDataFile"]
+const readTestingDataInput = modules["testing-data-io.js"]["readTestingDataInput"]
+const resolveTestingDataExportFormat = modules["testing-data-io.js"]["resolveTestingDataExportFormat"]
+const serializeDelimitedTestingData = modules["testing-data-io.js"]["serializeDelimitedTestingData"]
+const writeTestingDataFile = modules["testing-data-io.js"]["writeTestingDataFile"]
+export {TESTING_DATA_MAX_INPUT_BYTES, TESTING_DATA_MAX_XLSX_EXPANDED_BYTES, normalizeTestingDataPath, parseDelimitedTestingData, parseTestingDataText, readTestingDataFile, readTestingDataInput, resolveTestingDataExportFormat, serializeDelimitedTestingData, writeTestingDataFile};

package/dist/lib/testing-data-operations.js

@@ -1,91 +1,10 @@
-import { normalizeTestingDataTable, normalizeTestingDataTables, } from './testing-data-core.js';
-import { TestingGateway, } from './testing-gateway.js';
-import { sanitizeTestingOutput } from './testing-sanitization.js';
-import { exchangeTestingSession, testingSessionAuth, } from './testing-session.js';
-export async function listTestingDataTables(options) {
-    const response = await callTestingData({
-        endpoint: testingDataTablesEndpoint(options.projectId, {
-            fields: options.fields,
-            jobId: options.jobId,
-            name: options.name,
-            version: options.version,
-        }),
-        method: 'GET',
-    }, options);
-    return normalizeTestingDataTables(response).map((table) => sanitizeTestingDataTable(table));
-}
-export async function getTestingDataTable(options) {
-    const response = await callTestingData({
-        endpoint: testingDataTableEndpoint(options.projectId, options.tableId, {
-            jobId: options.jobId,
-            version: options.version,
-        }),
-        method: 'GET',
-    }, options);
-    return sanitizeTestingDataTable(normalizeTestingDataTable(response));
-}
-export async function createTestingDataTable(options) {
-    const response = await callTestingData({
-        body: options.body,
-        endpoint: testingDataTablesEndpoint(options.projectId, { jobId: options.jobId }),
-        method: 'POST',
-    }, options);
-    const table = sanitizeTestingDataTable(normalizeTestingDataTable(response));
-    return { id: table.id, version: table.version };
-}
-export async function updateTestingDataTable(options) {
-    const response = await callTestingData({
-        body: options.body,
-        endpoint: testingDataTableEndpoint(options.projectId, options.tableId, { jobId: options.jobId }),
-        method: 'PATCH',
-    }, options);
-    return sanitizeTestingDataTable(normalizeTestingDataTable(response));
-}
-export async function deleteTestingDataTable(options) {
-    await callTestingData({
-        endpoint: testingDataTableEndpoint(options.projectId, options.tableId, { jobId: options.jobId }),
-        method: 'DELETE',
-    }, options);
-    return { deleted: true, projectId: options.projectId, tableId: options.tableId };
-}
-export async function createTestingDataSession(options = {}) {
-    return exchangeTestingSession(options);
-}
-export function testingDataTablesEndpoint(projectId, filters = {}) {
-    return appendTestingDataQuery('/job-test-data', projectId, filters);
-}
-export function testingDataTableEndpoint(projectId, tableId, filters = {}) {
-    if (!Number.isSafeInteger(tableId) || tableId <= 0)
-        throw new Error('Data-table ID must be a positive integer.');
-    return appendTestingDataQuery(`/job-test-data/${tableId}`, projectId, filters);
-}
-async function callTestingData(request, options) {
-    const session = options.session ?? (await exchangeTestingSession(options));
-    return TestingGateway.call({
-        ...request,
-        auth: testingSessionAuth(session),
-        service: 'test-data',
-    }, options);
-}
-function appendTestingDataQuery(endpoint, projectId, filters) {
-    if (!Number.isSafeInteger(projectId) || projectId <= 0)
-        throw new Error('CRT project ID must be a positive integer.');
-    const query = new URLSearchParams({ projectId: projectId.toString() });
-    if (filters.jobId !== undefined)
-        query.set('jobId', filters.jobId.toString());
-    if (filters.name !== undefined)
-        query.set('name', filters.name);
-    if (filters.version !== undefined)
-        query.set('version', filters.version.toString());
-    if (filters.fields !== undefined)
-        query.set('fields', filters.fields);
-    return `${endpoint}?${query.toString()}`;
-}
-function sanitizeTestingDataTable(table) {
-    const { data, ...metadata } = table;
-    return {
-        ...sanitizeTestingOutput(metadata),
-        ...(data === undefined ? {} : { data }),
-    };
-}
-//# sourceMappingURL=testing-data-operations.js.map
+import {modules} from './runtime.js';
+const createTestingDataSession = modules["testing-data-operations.js"]["createTestingDataSession"]
+const createTestingDataTable = modules["testing-data-operations.js"]["createTestingDataTable"]
+const deleteTestingDataTable = modules["testing-data-operations.js"]["deleteTestingDataTable"]
+const getTestingDataTable = modules["testing-data-operations.js"]["getTestingDataTable"]
+const listTestingDataTables = modules["testing-data-operations.js"]["listTestingDataTables"]
+const testingDataTableEndpoint = modules["testing-data-operations.js"]["testingDataTableEndpoint"]
+const testingDataTablesEndpoint = modules["testing-data-operations.js"]["testingDataTablesEndpoint"]
+const updateTestingDataTable = modules["testing-data-operations.js"]["updateTestingDataTable"]
+export {createTestingDataSession, createTestingDataTable, deleteTestingDataTable, getTestingDataTable, listTestingDataTables, testingDataTableEndpoint, testingDataTablesEndpoint, updateTestingDataTable};

package/dist/lib/testing-data-types.js

@@ -1,3 +1,4 @@
-export const TESTING_DATA_HEADER_ORIENTATIONS = ['row', 'column'];
-export const TESTING_DATA_EXPORT_FORMATS = ['csv', 'tsv', 'xlsx'];
-//# sourceMappingURL=testing-data-types.js.map
+import {modules} from './runtime.js';
+const TESTING_DATA_EXPORT_FORMATS = modules["testing-data-types.js"]["TESTING_DATA_EXPORT_FORMATS"]
+const TESTING_DATA_HEADER_ORIENTATIONS = modules["testing-data-types.js"]["TESTING_DATA_HEADER_ORIENTATIONS"]
+export {TESTING_DATA_EXPORT_FORMATS, TESTING_DATA_HEADER_ORIENTATIONS};