@onequery/cli 0.1.39-win32-x64 → 0.1.40-darwin-arm64

package/package.json

@@ -1,6 +1,6 @@
 {
   "cpu": [
-    "x64"
+    "arm64"
   ],
   "description": "OneQuery CLI",
   "files": [
@@ -10,7 +10,7 @@
   "license": "Apache-2.0",
   "name": "@onequery/cli",
   "os": [
-    "win32"
+    "darwin"
   ],
   "publishConfig": {
     "access": "public"
@@ -20,5 +20,5 @@
     "url": "git+https://github.com/wordbricks/onequery.git",
     "directory": "apps/cli"
   },
-  "version": "0.1.39-win32-x64"
+  "version": "0.1.40-darwin-arm64"
 }

package/vendor/{x86_64-pc-windows-msvc → aarch64-apple-darwin}/server/onequery-server.mjs

@@ -121420,13 +121420,19 @@ const CLI_MAX_QUERY_MAX_BYTES = 4194304;
 const CLI_DEFAULT_QUERY_CELL_MAX_CHARS = 2e3;
 const CLI_MAX_QUERY_CELL_MAX_CHARS = 8e3;
 const CLI_DEFAULT_QUERY_TIMEOUT_MS = 3e4;
+const CLI_MAX_QUERY_TIMEOUT_MS = 12e4;
+const ELLIPSIS = "...";
+const ELLIPSIS_CHAR_COUNT = 3;
+const EMPTY_JSON_STRING_BYTE_LENGTH = 2;
+const EMPTY_JSON_ARRAY_BYTE_LENGTH = 2;
 object$1({
 	cellMaxChars: number$4().int().min(1).max(CLI_MAX_QUERY_CELL_MAX_CHARS).optional(),
 	maxBytes: number$4().int().min(1).max(CLI_MAX_QUERY_MAX_BYTES).optional(),
 	maxRows: number$4().int().min(1).max(CLI_MAX_QUERY_MAX_ROWS).optional(),
-	timeoutMs: number$4().int().min(1).max(12e4).optional()
+	timeoutMs: number$4().int().min(1).max(CLI_MAX_QUERY_TIMEOUT_MS).optional()
 }).meta({ id: "CliQueryResultWindow" });
 const textEncoder = new TextEncoder();
+const displayUnitSegmenter = typeof Intl !== "undefined" && typeof Intl.Segmenter === "function" ? new Intl.Segmenter(void 0, { granularity: "grapheme" }) : null;
 function resolveQueryResultWindow(input) {
 	return {
 		cellMaxChars: input.cellMaxChars ?? CLI_DEFAULT_QUERY_CELL_MAX_CHARS,
@@ -121445,29 +121451,145 @@ function applyQueryResultWindow(input) {
 	const clippedRows = rows.map((row) => row.map((cell) => truncateCell(cell, input.cellMaxChars)));
 	if (clippedRows.some((row, rowIndex) => row.some((cell, columnIndex) => cell !== rows[rowIndex]?.[columnIndex]))) truncated = true;
 	const boundedRows = [];
-	let usedBytes = 0;
+	if (input.maxBytes < EMPTY_JSON_ARRAY_BYTE_LENGTH) return {
+		rows: boundedRows,
+		truncated: truncated || clippedRows.length > 0
+	};
+	let usedBytes = EMPTY_JSON_ARRAY_BYTE_LENGTH;
 	for (const row of clippedRows) {
-		const rowBytes = textEncoder.encode(JSON.stringify(row)).length;
-		if (boundedRows.length > 0 && usedBytes + rowBytes > input.maxBytes) {
-			truncated = true;
-			break;
-		}
-		if (boundedRows.length === 0 && rowBytes > input.maxBytes) {
+		const rowSeparatorBytes = boundedRows.length > 0 ? 1 : 0;
+		const fittedRow = fitRowWithinBytes(row, input.maxBytes - usedBytes - rowSeparatorBytes);
+		if (fittedRow === null) {
 			truncated = true;
 			break;
 		}
-		boundedRows.push(row);
-		usedBytes += rowBytes;
+		if (!rowsEqual(fittedRow, row)) truncated = true;
+		boundedRows.push(fittedRow);
+		usedBytes += rowSeparatorBytes + rowByteLength(fittedRow);
 	}
 	return {
 		rows: boundedRows,
 		truncated
 	};
 }
+function fitRowWithinBytes(row, maxBytes) {
+	if (maxBytes <= 0) return null;
+	const cellPlans = row.map(buildCellPlan);
+	let rowBytes = rowByteLengthFromPlans(cellPlans);
+	if (rowBytes <= maxBytes) return [...row];
+	if (minimalRowByteLength(cellPlans.length) > maxBytes) return null;
+	for (let cellIndex = cellPlans.length - 1; cellIndex >= 0 && rowBytes > maxBytes; cellIndex -= 1) {
+		const cellPlan = cellPlans[cellIndex];
+		if (cellPlan === void 0) continue;
+		while (rowBytes > maxBytes) {
+			const shrink = buildNextShrink(cellPlan);
+			if (shrink === null) break;
+			cellPlan.stateIndex = shrink.nextStateIndex;
+			rowBytes -= shrink.bytesSaved;
+		}
+	}
+	if (rowBytes > maxBytes) return null;
+	return cellPlans.map(materializeCell);
+}
+function rowByteLength(row) {
+	return EMPTY_JSON_ARRAY_BYTE_LENGTH + Math.max(0, row.length - 1) + row.reduce((totalBytes, cell) => totalBytes + jsonStringByteLength(cell), 0);
+}
+function rowsEqual(left, right) {
+	return left.length === right.length && left.every((cell, index) => cell === right[index]);
+}
 function truncateCell(value, maxChars) {
 	if (value.length <= maxChars) return value;
-	if (maxChars <= 3) return ".".repeat(maxChars);
-	return `${value.slice(0, maxChars - 3)}...`;
+	const units = splitDisplayUnits(value);
+	if (units.length <= maxChars) return value;
+	return materializeTruncatedValue(value, units, maxChars);
+}
+function buildCellPlan(value) {
+	const units = splitDisplayUnits(value);
+	const prefixJsonInnerByteLengths = [0];
+	for (const unit of units) prefixJsonInnerByteLengths.push((prefixJsonInnerByteLengths.at(-1) ?? 0) + jsonStringInnerByteLength(unit));
+	return {
+		fullValue: value,
+		prefixJsonInnerByteLengths,
+		stateIndex: 0,
+		states: buildCellStates(value, units, prefixJsonInnerByteLengths),
+		units
+	};
+}
+function rowByteLengthFromPlans(cellPlans) {
+	return EMPTY_JSON_ARRAY_BYTE_LENGTH + Math.max(0, cellPlans.length - 1) + cellPlans.reduce((totalBytes, cellPlan) => totalBytes + (currentCellState(cellPlan)?.bytes ?? EMPTY_JSON_STRING_BYTE_LENGTH), 0);
+}
+function minimalRowByteLength(cellCount) {
+	return EMPTY_JSON_ARRAY_BYTE_LENGTH + Math.max(0, cellCount - 1) + cellCount * EMPTY_JSON_STRING_BYTE_LENGTH;
+}
+function buildNextShrink(cellPlan) {
+	const currentState = currentCellState(cellPlan);
+	const nextState = cellPlan.states[cellPlan.stateIndex + 1];
+	if (currentState === void 0 || nextState === void 0) return null;
+	return {
+		bytesSaved: currentState.bytes - nextState.bytes,
+		nextStateIndex: cellPlan.stateIndex + 1
+	};
+}
+function materializeCell(cellPlan) {
+	const currentState = currentCellState(cellPlan);
+	if (currentState === void 0) return "";
+	switch (currentState.kind) {
+		case "empty": return "";
+		case "dots": return ".".repeat(currentState.displayChars);
+		case "full": return cellPlan.fullValue;
+		case "truncated": return `${cellPlan.units.slice(0, currentState.retainedChars).join("")}${ELLIPSIS}`;
+	}
+}
+function materializeTruncatedValue(value, units, maxChars) {
+	if (maxChars <= 0) return "";
+	if (units.length <= maxChars) return value;
+	if (maxChars <= ELLIPSIS_CHAR_COUNT) return ".".repeat(maxChars);
+	return `${units.slice(0, maxChars - ELLIPSIS_CHAR_COUNT).join("")}${ELLIPSIS}`;
+}
+function splitDisplayUnits(value) {
+	if (displayUnitSegmenter === null) return Array.from(value);
+	return Array.from(displayUnitSegmenter.segment(value), ({ segment }) => segment);
+}
+function jsonStringByteLength(value) {
+	return EMPTY_JSON_STRING_BYTE_LENGTH + jsonStringInnerByteLength(value);
+}
+function jsonStringInnerByteLength(value) {
+	return textEncoder.encode(JSON.stringify(value)).length - EMPTY_JSON_STRING_BYTE_LENGTH;
+}
+function buildCellStates(value, units, prefixJsonInnerByteLengths) {
+	const candidateStates = [{
+		bytes: jsonStringByteLength(value),
+		displayChars: units.length,
+		kind: "full",
+		retainedChars: units.length
+	}];
+	for (let retainedChars = Math.max(units.length - ELLIPSIS_CHAR_COUNT, 0); retainedChars >= 1; retainedChars -= 1) candidateStates.push({
+		bytes: EMPTY_JSON_STRING_BYTE_LENGTH + (prefixJsonInnerByteLengths[retainedChars] ?? 0) + 3,
+		displayChars: retainedChars + ELLIPSIS_CHAR_COUNT,
+		kind: "truncated",
+		retainedChars
+	});
+	for (let dotCount = Math.min(ELLIPSIS_CHAR_COUNT, units.length); dotCount >= 1; dotCount -= 1) candidateStates.push({
+		bytes: EMPTY_JSON_STRING_BYTE_LENGTH + dotCount,
+		displayChars: dotCount,
+		kind: "dots",
+		retainedChars: 0
+	});
+	candidateStates.push({
+		bytes: EMPTY_JSON_STRING_BYTE_LENGTH,
+		displayChars: 0,
+		kind: "empty",
+		retainedChars: 0
+	});
+	const states = [];
+	for (const candidateState of candidateStates) {
+		const previousState = states.at(-1);
+		if (previousState === void 0 || candidateState.bytes < previousState.bytes) states.push(candidateState);
+	}
+	return states;
+}
+function currentCellState(cellPlan) {
+	return cellPlan.states[cellPlan.stateIndex];
 }
 //#endregion
 //#region packages/cli-server/src/connect/service/errors.ts