@gscdump/lakehouse 1.4.0 → 1.4.2

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/write/commit.mjs

@@ -0,0 +1,392 @@
+import { stringifyIcebergJson } from "../json.mjs";
+import { maxFieldId, validateSchemaForVersion } from "../schema.mjs";
+import { parseDecimalType } from "./conversions.mjs";
+import { validatePartitionSpecForWrite } from "./partition.mjs";
+async function fileCatalogCommit({ tableUrl, metadata, metadataFileName, currentVersion, staged, resolver, conditionalCommits }) {
+	if (!tableUrl) throw new Error("tableUrl is required");
+	if (!resolver?.writer) throw new Error("resolver.writer is required");
+	checkRequirements(metadata, staged.requirements);
+	const updated = applyUpdates(staged.updates.some((up) => up.action === "add-snapshot") ? metadata : {
+		...metadata,
+		"last-updated-ms": Date.now()
+	}, staged.updates);
+	const priorMetadataLog = metadata["metadata-log"] ?? [];
+	const derivedVersion = currentVersion ?? deriveCurrentVersion(priorMetadataLog);
+	const newVersion = derivedVersion + 1;
+	const currentMetadataPath = metadataFileName ? `${tableUrl}/metadata/${metadataFileName}` : `${tableUrl}/metadata/v${derivedVersion}.metadata.json`;
+	const newMetadataPath = `${tableUrl}/metadata/v${newVersion}.metadata.json`;
+	const appendedLog = [...priorMetadataLog, {
+		"timestamp-ms": metadata["last-updated-ms"],
+		"metadata-file": currentMetadataPath
+	}];
+	const max = Number(updated.properties?.["write.metadata.previous-versions-max"] ?? 100);
+	const droppedLog = max > 0 && appendedLog.length > max ? appendedLog.slice(0, appendedLog.length - max) : [];
+	const trimmedLog = droppedLog.length > 0 ? appendedLog.slice(-max) : appendedLog;
+	const newMetadata = {
+		...updated,
+		"metadata-log": trimmedLog
+	};
+	const metaWriter = conditionalCommits ? resolver.writer(newMetadataPath, { ifNoneMatch: "*" }) : resolver.writer(newMetadataPath);
+	metaWriter.appendBytes(new TextEncoder().encode(stringifyIcebergJson(newMetadata)));
+	await metaWriter.finish();
+	try {
+		const hintWriter = resolver.writer(`${tableUrl}/metadata/version-hint.text`);
+		hintWriter.appendBytes(new TextEncoder().encode(String(newVersion)));
+		await hintWriter.finish();
+	} catch {}
+	if (updated.properties?.["write.metadata.delete-after-commit.enabled"] === "true" && droppedLog.length > 0 && resolver.deleter) {
+		const { deleter } = resolver;
+		await Promise.allSettled(droppedLog.map((entry) => deleter(entry["metadata-file"])));
+	}
+	return newMetadata;
+}
+function deriveCurrentVersion(priorMetadataLog) {
+	if (priorMetadataLog.length === 0) return 1;
+	const match = (priorMetadataLog[priorMetadataLog.length - 1]["metadata-file"].split("/").pop() ?? "").match(/^(?:v(\d+)|0*(\d+)-[0-9a-f-]+)\.metadata\.json$/);
+	if (match) return Number(match[1] ?? match[2]) + 1;
+	return priorMetadataLog.length + 1;
+}
+function checkRequirements(metadata, requirements) {
+	for (const req of requirements) if (req.type === "assert-create") throw new Error("requirement failed: assert-create against an existing table");
+	else if (req.type === "assert-table-uuid") {
+		if (metadata["table-uuid"] !== req.uuid) throw new Error(`requirement failed: table-uuid expected ${req.uuid}, got ${metadata["table-uuid"]}`);
+	} else if (req.type === "assert-ref-snapshot-id") {
+		let current = (metadata.refs ?? {})[req.ref]?.["snapshot-id"] ?? null;
+		if (current === null && req.ref === "main") current = metadata["current-snapshot-id"] ?? null;
+		const expected = req["snapshot-id"];
+		if (!(current === expected || current != null && expected != null && BigInt(current) === BigInt(expected))) throw new Error(`requirement failed: ref ${req.ref} expected snapshot ${expected}, got ${current}`);
+	} else if (req.type === "assert-next-row-id") {
+		const current = Number(metadata["next-row-id"] ?? 0);
+		if (current !== req["next-row-id"]) throw new Error(`requirement failed: next-row-id expected ${req["next-row-id"]}, got ${current}`);
+	} else if (req.type === "assert-current-schema-id") {
+		const current = metadata["current-schema-id"];
+		if (current !== req["current-schema-id"]) throw new Error(`requirement failed: current-schema-id expected ${req["current-schema-id"]}, got ${current}`);
+	} else if (req.type === "assert-last-assigned-field-id") {
+		const current = metadata["last-column-id"];
+		if (current !== req["last-assigned-field-id"]) throw new Error(`requirement failed: last-assigned-field-id expected ${req["last-assigned-field-id"]}, got ${current}`);
+	} else if (req.type === "assert-last-assigned-partition-id") {
+		const current = metadata["last-partition-id"];
+		if (current !== req["last-assigned-partition-id"]) throw new Error(`requirement failed: last-assigned-partition-id expected ${req["last-assigned-partition-id"]}, got ${current}`);
+	} else if (req.type === "assert-default-spec-id") {
+		const current = metadata["default-spec-id"];
+		if (current !== req["default-spec-id"]) throw new Error(`requirement failed: default-spec-id expected ${req["default-spec-id"]}, got ${current}`);
+	} else if (req.type === "assert-default-sort-order-id") {
+		const current = metadata["default-sort-order-id"];
+		if (current !== req["default-sort-order-id"]) throw new Error(`requirement failed: default-sort-order-id expected ${req["default-sort-order-id"]}, got ${current}`);
+	} else throw new Error(`unknown requirement: ${JSON.stringify(req)}`);
+}
+function applyUpdates(metadata, updates) {
+	let next = { ...metadata };
+	for (const up of updates) if (up.action === "add-snapshot") {
+		const snap = up.snapshot;
+		const priorSnapshots = next.snapshots ?? [];
+		if (priorSnapshots.some((s) => s["snapshot-id"] === snap["snapshot-id"])) throw new Error(`add-snapshot: snapshot-id ${snap["snapshot-id"]} already exists`);
+		next = {
+			...next,
+			snapshots: [...priorSnapshots, snap],
+			"last-sequence-number": Math.max(next["last-sequence-number"] ?? 0, snap["sequence-number"]),
+			"last-updated-ms": snap["timestamp-ms"]
+		};
+		if (next["format-version"] >= 3 && snap["first-row-id"] !== void 0 && snap["added-rows"] !== void 0) {
+			const nextRowId = snap["first-row-id"] + snap["added-rows"];
+			next["next-row-id"] = Math.max(Number(next["next-row-id"] ?? 0), nextRowId);
+		}
+	} else if (up.action === "set-properties") next = {
+		...next,
+		properties: {
+			...next.properties,
+			...up.updates
+		}
+	};
+	else if (up.action === "remove-properties") {
+		const properties = { ...next.properties };
+		for (const key of up.removals) delete properties[key];
+		next = {
+			...next,
+			properties
+		};
+	} else if (up.action === "add-schema") {
+		const schemas = next.schemas ?? [];
+		let schemaId = up.schema["schema-id"];
+		if (schemaId === -1) schemaId = schemas.reduce((m, s) => Math.max(m, s["schema-id"]), -1) + 1;
+		else if (schemas.some((s) => s["schema-id"] === schemaId)) throw new Error(`add-schema: schema-id ${schemaId} already exists`);
+		const newSchema = {
+			...up.schema,
+			"schema-id": schemaId
+		};
+		validateSchemaForVersion(newSchema, next["format-version"]);
+		const priorLastColumnId = next["last-column-id"] ?? 0;
+		validateAssignedFieldIds(newSchema, currentAssignedIdIndex(schemas, next["current-schema-id"]), priorLastColumnId);
+		validateSchemaEvolution(schemas, newSchema, priorLastColumnId, next["format-version"]);
+		validateNewRequiredFields(newSchema, priorLastColumnId);
+		next = {
+			...next,
+			schemas: [...schemas, newSchema],
+			"last-column-id": Math.max(priorLastColumnId, maxFieldId(newSchema.fields))
+		};
+	} else if (up.action === "set-current-schema") {
+		let id = up["schema-id"];
+		const schemas = next.schemas ?? [];
+		if (id === -1) {
+			if (schemas.length === 0) throw new Error("set-current-schema: table has no schemas");
+			id = schemas[schemas.length - 1]["schema-id"];
+		} else if (!schemas.some((s) => s["schema-id"] === id)) throw new Error(`set-current-schema: schema-id ${id} not found`);
+		next = {
+			...next,
+			"current-schema-id": id
+		};
+	} else if (up.action === "add-sort-order") {
+		const orders = next["sort-orders"] ?? [];
+		let orderId = up["sort-order"]["order-id"];
+		if (orderId === -1) orderId = orders.reduce((m, o) => Math.max(m, o["order-id"]), -1) + 1;
+		else if (orders.some((o) => o["order-id"] === orderId)) throw new Error(`add-sort-order: order-id ${orderId} already exists`);
+		const newOrder = {
+			...up["sort-order"],
+			"order-id": orderId
+		};
+		next = {
+			...next,
+			"sort-orders": [...orders, newOrder]
+		};
+	} else if (up.action === "set-default-sort-order") {
+		let id = up["sort-order-id"];
+		const orders = next["sort-orders"] ?? [];
+		if (id === -1) {
+			if (orders.length === 0) throw new Error("set-default-sort-order: table has no sort orders");
+			id = orders[orders.length - 1]["order-id"];
+		} else if (!orders.some((o) => o["order-id"] === id)) throw new Error(`set-default-sort-order: sort-order-id ${id} not found`);
+		next = {
+			...next,
+			"default-sort-order-id": id
+		};
+	} else if (up.action === "add-spec") {
+		const specs = next["partition-specs"] ?? [];
+		let specId = up.spec["spec-id"];
+		if (specId === -1) specId = specs.reduce((m, s) => Math.max(m, s["spec-id"]), -1) + 1;
+		else if (specs.some((s) => s["spec-id"] === specId)) throw new Error(`add-spec: spec-id ${specId} already exists`);
+		const newSpec = {
+			...up.spec,
+			"spec-id": specId
+		};
+		validatePartitionSpecEvolution(specs, newSpec, currentSchemaForMetadata(next));
+		let nextLastPartitionId = next["last-partition-id"] ?? 0;
+		for (const f of newSpec.fields) if (f["field-id"] > nextLastPartitionId) nextLastPartitionId = f["field-id"];
+		next = {
+			...next,
+			"partition-specs": [...specs, newSpec],
+			"last-partition-id": nextLastPartitionId
+		};
+	} else if (up.action === "set-default-spec") {
+		let id = up["spec-id"];
+		const specs = next["partition-specs"] ?? [];
+		if (id === -1) {
+			if (specs.length === 0) throw new Error("set-default-spec: table has no partition specs");
+			id = specs[specs.length - 1]["spec-id"];
+		} else if (!specs.some((s) => s["spec-id"] === id)) throw new Error(`set-default-spec: spec-id ${id} not found`);
+		next = {
+			...next,
+			"default-spec-id": id
+		};
+	} else if (up.action === "remove-snapshots") {
+		const removeIds = new Set(up["snapshot-ids"]);
+		const snapshots = (next.snapshots ?? []).filter((s) => !removeIds.has(s["snapshot-id"]));
+		const log = (next["snapshot-log"] ?? []).filter((e) => !removeIds.has(e["snapshot-id"]));
+		next = {
+			...next,
+			snapshots,
+			"snapshot-log": log
+		};
+	} else if (up.action === "set-snapshot-ref") {
+		const ref = {
+			"snapshot-id": up["snapshot-id"],
+			type: up.type
+		};
+		if (up["min-snapshots-to-keep"] !== void 0) ref["min-snapshots-to-keep"] = up["min-snapshots-to-keep"];
+		if (up["max-snapshot-age-ms"] !== void 0) ref["max-snapshot-age-ms"] = up["max-snapshot-age-ms"];
+		if (up["max-ref-age-ms"] !== void 0) ref["max-ref-age-ms"] = up["max-ref-age-ms"];
+		next = {
+			...next,
+			refs: {
+				...next.refs,
+				[up["ref-name"]]: ref
+			}
+		};
+		if (up["ref-name"] === "main" && up.type === "branch") {
+			next["current-snapshot-id"] = up["snapshot-id"];
+			next["snapshot-log"] = [...next["snapshot-log"] ?? [], {
+				"timestamp-ms": next["last-updated-ms"],
+				"snapshot-id": up["snapshot-id"]
+			}];
+		}
+	} else throw new Error(`unknown update: ${JSON.stringify(up)}`);
+	return next;
+}
+function currentAssignedIdIndex(schemas, currentSchemaId) {
+	const currentSchema = schemas.find((s) => s["schema-id"] === currentSchemaId) ?? schemas[schemas.length - 1];
+	const assignedIds = /* @__PURE__ */ new Map();
+	if (currentSchema) indexAssignedFieldIds(currentSchema.fields, "", assignedIds);
+	return assignedIds;
+}
+function indexAssignedFieldIds(fields, prefix, assignedIds) {
+	for (const field of fields) {
+		const path = prefix ? `${prefix}.${field.name}` : field.name;
+		assignedIds.set(field.id, {
+			kind: "field",
+			path
+		});
+		indexAssignedTypeIds(field.type, path, assignedIds);
+	}
+}
+function indexAssignedTypeIds(type, path, assignedIds) {
+	if (typeof type === "string") return;
+	if (type.type === "struct") indexAssignedFieldIds(type.fields, path, assignedIds);
+	else if (type.type === "list") {
+		assignedIds.set(type["element-id"], {
+			kind: "list element",
+			path: `${path}.element`
+		});
+		indexAssignedTypeIds(type.element, `${path}.element`, assignedIds);
+	} else if (type.type === "map") {
+		assignedIds.set(type["key-id"], {
+			kind: "map key",
+			path: `${path}.key`
+		});
+		assignedIds.set(type["value-id"], {
+			kind: "map value",
+			path: `${path}.value`
+		});
+		indexAssignedTypeIds(type.key, `${path}.key`, assignedIds);
+		indexAssignedTypeIds(type.value, `${path}.value`, assignedIds);
+	}
+}
+function validateAssignedFieldIds(schema, priorAssignedIds, priorLastColumnId) {
+	validateAssignedFields(schema.fields, "", priorAssignedIds, priorLastColumnId);
+}
+function validateAssignedFields(fields, prefix, priorAssignedIds, priorLastColumnId) {
+	for (const field of fields) {
+		const path = prefix ? `${prefix}.${field.name}` : field.name;
+		validateAssignedId(field.id, "field", path, priorAssignedIds, priorLastColumnId);
+		validateAssignedTypeIds(field.type, path, priorAssignedIds, priorLastColumnId);
+	}
+}
+function validateAssignedTypeIds(type, path, priorAssignedIds, priorLastColumnId) {
+	if (typeof type === "string") return;
+	if (type.type === "struct") validateAssignedFields(type.fields, path, priorAssignedIds, priorLastColumnId);
+	else if (type.type === "list") {
+		validateAssignedId(type["element-id"], "list element", `${path}.element`, priorAssignedIds, priorLastColumnId);
+		validateAssignedTypeIds(type.element, `${path}.element`, priorAssignedIds, priorLastColumnId);
+	} else if (type.type === "map") {
+		validateAssignedId(type["key-id"], "map key", `${path}.key`, priorAssignedIds, priorLastColumnId);
+		validateAssignedId(type["value-id"], "map value", `${path}.value`, priorAssignedIds, priorLastColumnId);
+		validateAssignedTypeIds(type.key, `${path}.key`, priorAssignedIds, priorLastColumnId);
+		validateAssignedTypeIds(type.value, `${path}.value`, priorAssignedIds, priorLastColumnId);
+	}
+}
+function validateAssignedId(id, kind, path, priorAssignedIds, priorLastColumnId) {
+	if (id > priorLastColumnId) return;
+	const prior = priorAssignedIds.get(id);
+	if (!prior) throw new Error(`add-schema: ${kind} ${path} uses unassigned id ${id} (last-column-id ${priorLastColumnId})`);
+	if (prior.kind !== kind) throw new Error(`add-schema: ${kind} ${path} uses id ${id} previously assigned to ${prior.kind} ${prior.path}`);
+}
+function validateNewRequiredFields(schema, priorLastColumnId) {
+	for (const field of schema.fields) if (field.id > priorLastColumnId && field.required) {
+		if (field["initial-default"] == null) throw new Error(`add-schema: required field ${field.name} (id ${field.id}) needs a non-null initial-default`);
+		if (field["write-default"] == null) throw new Error(`add-schema: required field ${field.name} (id ${field.id}) needs a non-null write-default`);
+	}
+}
+function validateSchemaEvolution(schemas, newSchema, priorLastColumnId, formatVersion) {
+	for (const field of newSchema.fields) {
+		if (field.id > priorLastColumnId) continue;
+		const prior = latestFieldById(schemas, field.id);
+		if (!prior) continue;
+		if (!canPromoteType(prior.type, field.type, formatVersion)) throw new Error(`add-schema: cannot promote field ${field.name} from ${typeToString(prior.type)} to ${typeToString(field.type)}`);
+		if (!defaultsEqual(prior["initial-default"], field["initial-default"])) throw new Error(`add-schema: initial-default for field ${field.name} cannot change`);
+	}
+}
+function latestFieldById(schemas, id) {
+	for (let i = schemas.length - 1; i >= 0; i--) {
+		const field = schemas[i].fields.find((f) => f.id === id);
+		if (field) return field;
+	}
+}
+function canPromoteType(from, to, formatVersion) {
+	if (typesEqual(from, to)) return true;
+	if (typeof from !== "string" || typeof to !== "string") return false;
+	if (formatVersion >= 3 && from === "unknown") return true;
+	if (from === "int" && to === "long") return true;
+	if (from === "float" && to === "double") return true;
+	if (formatVersion >= 3 && from === "date" && (to === "timestamp" || to === "timestamp_ns")) return true;
+	return decimalPromotionAllowed(from, to);
+}
+function typesEqual(a, b) {
+	if (typeof a === "string" || typeof b === "string") return a === b;
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+function decimalPromotionAllowed(from, to) {
+	const a = parseDecimalType(from);
+	const b = parseDecimalType(to);
+	return Boolean(a && b && b.precision > a.precision && b.scale === a.scale);
+}
+function typeToString(type) {
+	return typeof type === "string" ? type : JSON.stringify(type);
+}
+function defaultsEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!defaultsEqual(a[i], b[i])) return false;
+		return true;
+	}
+	const aKeys = Object.keys(a);
+	const bKeys = Object.keys(b);
+	if (aKeys.length !== bKeys.length) return false;
+	for (const key of aKeys) {
+		if (!Object.hasOwn(b, key)) return false;
+		if (!defaultsEqual(a[key], b[key])) return false;
+	}
+	return true;
+}
+function validatePartitionSpecEvolution(specs, newSpec, schema) {
+	validateWritablePartitionSpec(newSpec, schema);
+	if (specs.some((spec) => partitionSpecsEquivalent(spec, newSpec))) throw new Error("add-spec: equivalent partition spec already exists");
+	for (const field of newSpec.fields) {
+		const equivalent = equivalentPartitionField(specs, field);
+		if (equivalent && equivalent["field-id"] !== field["field-id"]) throw new Error(`add-spec: partition field ${field.name} must reuse field-id ${equivalent["field-id"]}`);
+	}
+}
+function validateWritablePartitionSpec(spec, schema) {
+	try {
+		validatePartitionSpecForWrite(schema, spec, "add-spec");
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		if (message.startsWith("unsupported partition transform: ")) throw new Error(`add-spec: ${message}`);
+		throw err;
+	}
+}
+function currentSchemaForMetadata(metadata) {
+	const schema = metadata.schemas?.find((s) => s["schema-id"] === metadata["current-schema-id"]);
+	if (!schema) throw new Error("add-spec: current schema not found in metadata");
+	return schema;
+}
+function equivalentPartitionField(specs, field) {
+	for (const spec of specs) {
+		const found = spec.fields.find((existing) => partitionFieldsEquivalent(existing, field));
+		if (found) return found;
+	}
+}
+function partitionSpecsEquivalent(a, b) {
+	if (a.fields.length !== b.fields.length) return false;
+	for (let i = 0; i < a.fields.length; i++) if (!partitionFieldsEquivalent(a.fields[i], b.fields[i])) return false;
+	return true;
+}
+function partitionFieldsEquivalent(a, b) {
+	return a["source-id"] === b["source-id"] && idsListEquivalent(a["source-ids"], b["source-ids"]) && a.transform === b.transform && a.name === b.name;
+}
+function idsListEquivalent(a, b) {
+	if (a === void 0 || b === void 0) return a === b;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+export { applyUpdates, checkRequirements, fileCatalogCommit };

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/write/conversions.mjs

@@ -0,0 +1,59 @@
+function parseDecimalType(type) {
+	const m = /^decimal\((\d+),\s*(\d+)\)$/.exec(type);
+	if (!m) return void 0;
+	return {
+		precision: parseInt(m[1], 10),
+		scale: parseInt(m[2], 10)
+	};
+}
+function decimalRequiredBytes(precision) {
+	const limit = 10n ** BigInt(precision);
+	let n = 1;
+	let bound = 128n;
+	while (limit > bound) {
+		n++;
+		bound <<= 8n;
+	}
+	return n;
+}
+function decimalToFixedBytes(value, precision, scale, label) {
+	const size = decimalRequiredBytes(precision);
+	if (value instanceof Uint8Array) {
+		if (value.length !== size) throw new Error(`expected ${label}`);
+		return value;
+	}
+	if (typeof value !== "number" && typeof value !== "bigint") throw new Error(`expected ${label}`);
+	const factor = 10n ** BigInt(scale);
+	const unscaled = typeof value === "bigint" ? value * factor : BigInt(Math.round(value * Number(factor)));
+	const limit = 10n ** BigInt(precision);
+	if (unscaled >= limit || unscaled <= -limit) throw new Error(`${label} exceeds precision ${precision}`);
+	return bigintToFixedBytes(unscaled, size, label);
+}
+function toUint8Array(value) {
+	return value instanceof Uint8Array ? value : new Uint8Array(value);
+}
+function uuidToBytes(value, label) {
+	if (value instanceof Uint8Array) {
+		if (value.length !== 16) throw new Error(`expected ${label}`);
+		return value;
+	}
+	if (typeof value !== "string") throw new Error(`expected ${label}`);
+	const hex = value.toLowerCase().replace(/-/g, "");
+	if (!/^[0-9a-f]{32}$/.test(hex)) throw new Error(`expected ${label}`);
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+	return bytes;
+}
+function bigintToFixedBytes(value, size, label) {
+	const bytes = new Uint8Array(size);
+	let v = value;
+	for (let i = size - 1; i >= 0; i--) {
+		bytes[i] = Number(v & 255n);
+		v >>= 8n;
+	}
+	const negative = value < 0n;
+	const signBitSet = (bytes[0] & 128) !== 0;
+	if (!negative && (v !== 0n || signBitSet) || negative && (v !== -1n || !signBitSet)) throw new Error(`${label} does not fit in ${size} bytes`);
+	return bytes;
+}
+export { decimalRequiredBytes, decimalToFixedBytes, parseDecimalType, toUint8Array, uuidToBytes };

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/write/delete-file.mjs

@@ -0,0 +1,52 @@
+import { computeColumnStats } from "./stats.mjs";
+import { writeParquet } from "./parquet.mjs";
+const POSITION_DELETE_SCHEMA = {
+	type: "struct",
+	"schema-id": 0,
+	fields: [{
+		id: 2147483546,
+		name: "file_path",
+		required: true,
+		type: "string"
+	}, {
+		id: 2147483545,
+		name: "pos",
+		required: true,
+		type: "long"
+	}]
+};
+async function writePositionDeleteFile({ writer, deletes, codec }) {
+	if (!deletes?.length) throw new Error("writePositionDeleteFile requires at least one delete");
+	const records = deletes.map((d) => {
+		if (typeof d.file_path !== "string" || !d.file_path) throw new Error("position delete file_path must be a non-empty string");
+		if (d.pos === void 0 || d.pos === null) throw new Error("position delete pos is required");
+		const pos = typeof d.pos === "bigint" ? d.pos : BigInt(d.pos);
+		if (pos < 0n) throw new Error(`position delete pos must be non-negative: ${pos}`);
+		return {
+			file_path: d.file_path,
+			pos
+		};
+	});
+	records.sort((a, b) => {
+		if (a.file_path < b.file_path) return -1;
+		if (a.file_path > b.file_path) return 1;
+		if (a.pos < b.pos) return -1;
+		if (a.pos > b.pos) return 1;
+		return 0;
+	});
+	await writeParquet({
+		writer,
+		schema: POSITION_DELETE_SCHEMA,
+		records,
+		codec
+	});
+	const { value_counts, null_value_counts, lower_bounds, upper_bounds } = computeColumnStats(records, POSITION_DELETE_SCHEMA);
+	return {
+		record_count: BigInt(records.length),
+		value_counts,
+		null_value_counts,
+		lower_bounds,
+		upper_bounds
+	};
+}
+export { writePositionDeleteFile };

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/write/geospatial.mjs

@@ -0,0 +1,72 @@
+function isGeoType(name) {
+	return name.startsWith("geometry") || name.startsWith("geography");
+}
+function computeGeoBounds(records, field) {
+	let partial;
+	let nulls = 0n;
+	const writeDefault = field["write-default"];
+	for (const record of records) {
+		let v = record[field.name];
+		if (v === void 0 && writeDefault !== void 0) v = writeDefault;
+		if (v === null || v === void 0) {
+			nulls++;
+			continue;
+		}
+		if (typeof v !== "object") throw new Error("geospatial column expects GeoJSON geometries");
+		partial = extendBoundsFromGeometry(partial, v);
+	}
+	const result = {
+		value_count: BigInt(records.length),
+		null_count: nulls
+	};
+	const { xmin, ymin, xmax, ymax, zmin, zmax, mmin, mmax } = partial ?? {};
+	if (xmin === void 0 || ymin === void 0 || xmax === void 0 || ymax === void 0) return result;
+	const hasZ = zmin !== void 0;
+	const hasM = mmin !== void 0;
+	return {
+		...result,
+		lower: encodeGeoPoint(xmin, ymin, zmin, mmin, hasZ, hasM),
+		upper: encodeGeoPoint(xmax, ymax, zmax, mmax, hasZ, hasM)
+	};
+}
+function extendBoundsFromGeometry(bbox, geometry) {
+	if (geometry.type === "GeometryCollection") {
+		for (const child of geometry.geometries || []) bbox = extendBoundsFromGeometry(bbox, child);
+		return bbox;
+	}
+	return extendBoundsFromCoordinates(bbox, geometry.coordinates);
+}
+function extendBoundsFromCoordinates(bbox, coordinates) {
+	if (typeof coordinates[0] === "number") {
+		bbox = updateAxis(bbox, "xmin", "xmax", coordinates[0]);
+		bbox = updateAxis(bbox, "ymin", "ymax", coordinates[1]);
+		if (coordinates.length > 2) bbox = updateAxis(bbox, "zmin", "zmax", coordinates[2]);
+		if (coordinates.length > 3) bbox = updateAxis(bbox, "mmin", "mmax", coordinates[3]);
+		return bbox;
+	}
+	for (const child of coordinates) bbox = extendBoundsFromCoordinates(bbox, child);
+	return bbox;
+}
+function updateAxis(bbox, minKey, maxKey, value) {
+	if (value === void 0 || !Number.isFinite(value)) return bbox;
+	if (!bbox) bbox = {};
+	const min = bbox[minKey];
+	const max = bbox[maxKey];
+	if (min === void 0 || value < min) bbox[minKey] = value;
+	if (max === void 0 || value > max) bbox[maxKey] = value;
+	return bbox;
+}
+function encodeGeoPoint(x, y, z, m, hasZ, hasM) {
+	const len = !hasZ && !hasM ? 16 : hasZ && !hasM ? 24 : 32;
+	const buf = new ArrayBuffer(len);
+	const view = new DataView(buf);
+	view.setFloat64(0, x, true);
+	view.setFloat64(8, y, true);
+	if (len === 24) view.setFloat64(16, z, true);
+	else if (len === 32) {
+		view.setFloat64(16, hasZ ? z : NaN, true);
+		view.setFloat64(24, m, true);
+	}
+	return new Uint8Array(buf);
+}
+export { computeGeoBounds, isGeoType };