@fdm-monster/server 2.0.10 → 2.0.11

package/dist/utils/bgcode/bgcode.utils.js

@@ -1,288 +1,199 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get decompressBlock () {
-        return decompressBlock;
-    },
-    get extractMetadataFromBlocks () {
-        return extractMetadataFromBlocks;
-    },
-    get getBlockData () {
-        return getBlockData;
-    },
-    get getBlockParsedParameters () {
-        return getBlockParsedParameters;
-    },
-    get parseBlockHeader () {
-        return parseBlockHeader;
-    },
-    get parseBlockHeaders () {
-        return parseBlockHeaders;
-    },
-    get parseBlockParameters () {
-        return parseBlockParameters;
-    },
-    get parseFileHeader () {
-        return parseFileHeader;
-    }
-});
-const _bgcodeconstants = require("./bgcode.constants");
-const _bgcodetypes = require("./bgcode.types");
-const _nodezlib = require("node:zlib");
-const _heatshrinkdecoder = require("./heatshrink-decoder");
+import { BgCodeBlockParameterSizes, BgCodeBlockTypes, BgCodeChecksumTypeSize, BgCodeCompressionInfo, BgCodeCompressionName } from "./bgcode.types.js";
+import { BGCODE_EXPECTED_HEADERS, BGCODE_HEADER_MARKER } from "./bgcode.constants.js";
+import { HeatshrinkDecoder } from "./heatshrink-decoder.js";
+import { inflateSync } from "node:zlib";
+//#region src/utils/bgcode/bgcode.utils.ts
 async function parseFileHeader(fileHandle) {
-    const buffer = Buffer.alloc(_bgcodeconstants.BGCODE_HEADER_SIZE);
-    await fileHandle.read(buffer);
-    if (buffer.length < _bgcodeconstants.BGCODE_HEADER_SIZE) {
-        throw new Error("File too small to be a valid BGCode file");
-    }
-    const magic = buffer.toString("ascii", 0, 4);
-    if (magic !== _bgcodeconstants.BGCODE_HEADER_MARKER) {
-        throw new Error(`Invalid BGCode file: magic number not found (got "${magic}", expected ${_bgcodeconstants.BGCODE_HEADER_MARKER})`);
-    }
-    const version = buffer.readUInt32LE(4);
-    const checksumType = buffer.readUInt16LE(8);
-    return {
-        magic,
-        version,
-        checksumType
-    };
+	const buffer = Buffer.alloc(10);
+	await fileHandle.read(buffer);
+	if (buffer.length < 10) throw new Error("File too small to be a valid BGCode file");
+	const magic = buffer.toString("ascii", 0, 4);
+	if (magic !== "GCDE") throw new Error(`Invalid BGCode file: magic number not found (got "${magic}", expected ${BGCODE_HEADER_MARKER})`);
+	return {
+		magic,
+		version: buffer.readUInt32LE(4),
+		checksumType: buffer.readUInt16LE(8)
+	};
 }
 async function parseBlockHeaders(fileHandle, fileSize, checksumType, skipGcode) {
-    let offset = _bgcodeconstants.BGCODE_HEADER_SIZE;
-    const blockHeaders = [];
-    let currentExpectedHeaderIndex = 0;
-    while(offset < fileSize){
-        const blockHeader = await parseBlockHeader(fileHandle, fileSize, offset, checksumType);
-        if (skipGcode && blockHeader.type == _bgcodetypes.BgCodeBlockTypes.GCode) {
-            break;
-        }
-        const expectedType = _bgcodeconstants.BGCODE_EXPECTED_HEADERS[currentExpectedHeaderIndex];
-        if (blockHeader.type !== expectedType) {
-            const nextExpectedType = _bgcodeconstants.BGCODE_EXPECTED_HEADERS[currentExpectedHeaderIndex + 1];
-            if (blockHeader.type !== nextExpectedType) {
-                throw new Error(`Unexpected header header type ${blockHeader.type}, expected either ${expectedType} or next ${nextExpectedType}`);
-            }
-            currentExpectedHeaderIndex++;
-        }
-        if (Number.isNaN(blockHeader.blockSize)) {
-            throw new Error(`Unexpected blockHeader.blockSize ${blockHeader.blockSize}`);
-        }
-        offset += blockHeader.blockSize;
-        blockHeaders.push(blockHeader);
-    }
-    return blockHeaders;
+	let offset = 10;
+	const blockHeaders = [];
+	let currentExpectedHeaderIndex = 0;
+	while (offset < fileSize) {
+		const blockHeader = await parseBlockHeader(fileHandle, fileSize, offset, checksumType);
+		if (skipGcode && blockHeader.type == BgCodeBlockTypes.GCode) break;
+		const expectedType = BGCODE_EXPECTED_HEADERS[currentExpectedHeaderIndex];
+		if (blockHeader.type !== expectedType) {
+			const nextExpectedType = BGCODE_EXPECTED_HEADERS[currentExpectedHeaderIndex + 1];
+			if (blockHeader.type !== nextExpectedType) throw new Error(`Unexpected header header type ${blockHeader.type}, expected either ${expectedType} or next ${nextExpectedType}`);
+			currentExpectedHeaderIndex++;
+		}
+		if (Number.isNaN(blockHeader.blockSize)) throw new Error(`Unexpected blockHeader.blockSize ${blockHeader.blockSize}`);
+		offset += blockHeader.blockSize;
+		blockHeaders.push(blockHeader);
+	}
+	return blockHeaders;
 }
 async function parseBlockHeader(fileHandle, fileSize, blockStartOffset, checksumType) {
-    if (blockStartOffset + _bgcodeconstants.BGCODE_MAX_BLOCK_HEADER_SIZE > fileSize) {
-        throw new Error("Not enough data for block header");
-    }
-    const buffer = Buffer.alloc(_bgcodeconstants.BGCODE_MAX_BLOCK_HEADER_SIZE);
-    await fileHandle.read({
-        buffer,
-        offset: 0,
-        length: _bgcodeconstants.BGCODE_MAX_BLOCK_HEADER_SIZE,
-        position: blockStartOffset
-    });
-    const type = buffer.readUInt16LE(0);
-    if (type > _bgcodeconstants.BGCODE_MAX_BLOCK_TYPE) {
-        throw new Error(`Block header type ${type} exceeds ${_bgcodeconstants.BGCODE_MAX_BLOCK_TYPE}, cant parse block`);
-    }
-    const compression = buffer.readUInt16LE(2);
-    if (compression > _bgcodeconstants.BGCODE_MAX_COMPRESSION) {
-        throw new Error(`Block header compression ${compression} exceeds ${_bgcodeconstants.BGCODE_MAX_COMPRESSION}, cant parse block`);
-    }
-    const uncompressedSize = buffer.readUInt32LE(4);
-    if (uncompressedSize === 0) {
-        throw new Error(`Uncompressed Size is 0`);
-    }
-    let compressedSize = 0;
-    let headerSize = _bgcodeconstants.BGCODE_MIN_BLOCK_HEADER_SIZE;
-    if (compression > 0) {
-        compressedSize = buffer.readUInt32LE(8);
-        if (compressedSize === 0) {
-            throw new Error(`Compression is ${_bgcodetypes.BgCodeCompressionName[compression]} but compressed size is ${compressedSize}}`);
-        }
-        headerSize = _bgcodeconstants.BGCODE_MAX_BLOCK_HEADER_SIZE;
-    }
-    const checksumSize = calculateChecksumSize(checksumType);
-    const blockSize = calculateBlockSize(checksumSize, type, compression, uncompressedSize, compressedSize);
-    const parameterOffset = blockStartOffset + headerSize;
-    const parametersSize = calculateParameterSize(type);
-    const parameterBuffer = await getBlockParsedParameters(fileHandle, parameterOffset, parametersSize);
-    const parameters = parseBlockParameters(type, parameterBuffer);
-    const dataOffset = parameterOffset + parametersSize;
-    const dataSize = blockSize - parametersSize - checksumSize;
-    const checksumOffset = dataOffset + dataSize;
-    return {
-        type,
-        compression,
-        uncompressedSize,
-        compressedSize,
-        blockSize,
-        blockStartOffset,
-        headerSize,
-        parameterOffset,
-        parameters,
-        parametersSize,
-        dataOffset,
-        dataSize,
-        checksumOffset,
-        checksumSize,
-        checksumType
-    };
+	if (blockStartOffset + 12 > fileSize) throw new Error("Not enough data for block header");
+	const buffer = Buffer.alloc(12);
+	await fileHandle.read({
+		buffer,
+		offset: 0,
+		length: 12,
+		position: blockStartOffset
+	});
+	const type = buffer.readUInt16LE(0);
+	if (type > 5) throw new Error(`Block header type ${type} exceeds 5, cant parse block`);
+	const compression = buffer.readUInt16LE(2);
+	if (compression > 3) throw new Error(`Block header compression ${compression} exceeds 3, cant parse block`);
+	const uncompressedSize = buffer.readUInt32LE(4);
+	if (uncompressedSize === 0) throw new Error(`Uncompressed Size is 0`);
+	let compressedSize = 0;
+	let headerSize = 8;
+	if (compression > 0) {
+		compressedSize = buffer.readUInt32LE(8);
+		if (compressedSize === 0) throw new Error(`Compression is ${BgCodeCompressionName[compression]} but compressed size is ${compressedSize}}`);
+		headerSize = 12;
+	}
+	const checksumSize = calculateChecksumSize(checksumType);
+	const blockSize = calculateBlockSize(checksumSize, type, compression, uncompressedSize, compressedSize);
+	const parameterOffset = blockStartOffset + headerSize;
+	const parametersSize = calculateParameterSize(type);
+	const parameters = parseBlockParameters(type, await getBlockParsedParameters(fileHandle, parameterOffset, parametersSize));
+	const dataOffset = parameterOffset + parametersSize;
+	const dataSize = blockSize - parametersSize - checksumSize;
+	const checksumOffset = dataOffset + dataSize;
+	return {
+		type,
+		compression,
+		uncompressedSize,
+		compressedSize,
+		blockSize,
+		blockStartOffset,
+		headerSize,
+		parameterOffset,
+		parameters,
+		parametersSize,
+		dataOffset,
+		dataSize,
+		checksumOffset,
+		checksumSize,
+		checksumType
+	};
 }
 async function getBlockParsedParameters(fileHandle, parameterOffset, parametersSize) {
-    const parameters = Buffer.alloc(parametersSize);
-    if (parametersSize > 0) {
-        await fileHandle.read({
-            buffer: parameters,
-            offset: 0,
-            length: parametersSize,
-            position: parameterOffset
-        });
-    }
-    return parameters;
+	const parameters = Buffer.alloc(parametersSize);
+	if (parametersSize > 0) await fileHandle.read({
+		buffer: parameters,
+		offset: 0,
+		length: parametersSize,
+		position: parameterOffset
+	});
+	return parameters;
 }
 async function getBlockData(fileHandle, blockHeader) {
-    if (blockHeader.blockSize === 0) {
-        throw new Error("Cant get block data for block with size 0");
-    }
-    if (blockHeader.blockSize === 1E3) {
-        throw new Error(`Cant get block data for block with size ${blockHeader.blockSize} > ${1E3}`);
-    }
-    const data = Buffer.alloc(blockHeader.dataSize);
-    await fileHandle.read({
-        buffer: data,
-        offset: 0,
-        length: blockHeader.dataSize,
-        position: blockHeader.dataOffset
-    });
-    return data;
+	if (blockHeader.blockSize === 0) throw new Error("Cant get block data for block with size 0");
+	if (blockHeader.blockSize === 1e3) throw new Error(`Cant get block data for block with size ${blockHeader.blockSize} > 1000`);
+	const data = Buffer.alloc(blockHeader.dataSize);
+	await fileHandle.read({
+		buffer: data,
+		offset: 0,
+		length: blockHeader.dataSize,
+		position: blockHeader.dataOffset
+	});
+	return data;
 }
 function decompressBlock(compression, data) {
-    const info = _bgcodetypes.BgCodeCompressionInfo[compression];
-    switch(info.kind){
-        case "none":
-            return data;
-        case "deflate":
-            return (0, _nodezlib.inflateSync)(data);
-        case "heatshrink":
-            const decoder = new _heatshrinkdecoder.HeatshrinkDecoder(info.window, info.lookahead);
-            return decoder.decompress(data);
-        default:
-            throw new Error(`Unknown compression type: ${compression}`);
-    }
+	const info = BgCodeCompressionInfo[compression];
+	switch (info.kind) {
+		case "none": return data;
+		case "deflate": return inflateSync(data);
+		case "heatshrink": return new HeatshrinkDecoder(info.window, info.lookahead).decompress(data);
+		default: throw new Error(`Unknown compression type: ${compression}`);
+	}
 }
 function parseBlockParameters(blockType, parameters) {
-    const parameterSize = _bgcodetypes.BgCodeBlockParameterSizes[blockType];
-    if (parameters.length !== parameterSize) {
-        throw new Error(`Block Parameters should be exactly ${parameterSize} bytes long`);
-    }
-    if (blockType === _bgcodetypes.BgCodeBlockTypes.Thumbnail) {
-        return {
-            format: calculateThumbnailFormat(parameters.readUInt16LE(0)),
-            width: parameters.readUInt16LE(2),
-            height: parameters.readUInt16LE(4)
-        };
-    }
-    return {
-        encoding: parameters.readUInt16LE(0)
-    };
+	const parameterSize = BgCodeBlockParameterSizes[blockType];
+	if (parameters.length !== parameterSize) throw new Error(`Block Parameters should be exactly ${parameterSize} bytes long`);
+	if (blockType === BgCodeBlockTypes.Thumbnail) return {
+		format: calculateThumbnailFormat(parameters.readUInt16LE(0)),
+		width: parameters.readUInt16LE(2),
+		height: parameters.readUInt16LE(4)
+	};
+	return { encoding: parameters.readUInt16LE(0) };
 }
 function calculateBlockSize(checksumSize, blockType, compression, uncompressedSize, compressedSize) {
-    const headerSize = compression > 0 ? 12 : 8;
-    const dataSize = compression === 0 ? uncompressedSize : compressedSize;
-    const parametersSize = blockType === _bgcodetypes.BgCodeBlockTypes.Thumbnail ? 6 : 2;
-    return headerSize + parametersSize + dataSize + checksumSize;
+	const headerSize = compression > 0 ? 12 : 8;
+	const dataSize = compression === 0 ? uncompressedSize : compressedSize;
+	return headerSize + (blockType === BgCodeBlockTypes.Thumbnail ? 6 : 2) + dataSize + checksumSize;
 }
 function calculateChecksumSize(checksumType) {
-    if (checksumType > _bgcodeconstants.BGCODE_MAX_CHECKSUM_TYPE) {
-        throw new Error(`Checksum type ${checksumType} exceeds max ${_bgcodeconstants.BGCODE_MAX_CHECKSUM_TYPE}`);
-    }
-    return _bgcodetypes.BgCodeChecksumTypeSize[checksumType];
+	if (checksumType > 1) throw new Error(`Checksum type ${checksumType} exceeds max 1`);
+	return BgCodeChecksumTypeSize[checksumType];
 }
 function calculateParameterSize(blockType) {
-    if (blockType > _bgcodeconstants.BGCODE_MAX_BLOCK_TYPE) {
-        throw new Error(`Checksum type ${blockType} exceeds max ${_bgcodeconstants.BGCODE_MAX_BLOCK_TYPE}`);
-    }
-    return _bgcodetypes.BgCodeBlockParameterSizes[blockType];
+	if (blockType > 5) throw new Error(`Checksum type ${blockType} exceeds max 5`);
+	return BgCodeBlockParameterSizes[blockType];
 }
 function calculateThumbnailFormat(formatParameter) {
-    if (formatParameter > _bgcodeconstants.BGCODE_PARAMETER_THUMBNAIL_MAX_FORMAT) {
-        throw new Error(`Thumbnail format type ${formatParameter} exceeds max ${_bgcodeconstants.BGCODE_PARAMETER_THUMBNAIL_MAX_FORMAT}`);
-    }
-    return formatParameter;
+	if (formatParameter > 2) throw new Error(`Thumbnail format type ${formatParameter} exceeds max 2`);
+	return formatParameter;
 }
 async function extractMetadataFromBlocks(fileHandle, blockHeaders) {
-    const metadata = {};
-    const metadataBlocks = blockHeaders.filter((b)=>b.type === _bgcodetypes.BgCodeBlockTypes.FileMetadata || b.type === _bgcodetypes.BgCodeBlockTypes.SlicerMetadata || b.type === _bgcodetypes.BgCodeBlockTypes.PrinterMetadata || b.type === _bgcodetypes.BgCodeBlockTypes.PrintMetadata);
-    for (const header of metadataBlocks){
-        const blockData = await getBlockData(fileHandle, header);
-        const data = decompressBlock(header.compression, blockData);
-        const text = data.toString("utf8");
-        extractMetadataFromText(text, metadata);
-    }
-    return metadata;
+	const metadata = {};
+	const metadataBlocks = blockHeaders.filter((b) => b.type === BgCodeBlockTypes.FileMetadata || b.type === BgCodeBlockTypes.SlicerMetadata || b.type === BgCodeBlockTypes.PrinterMetadata || b.type === BgCodeBlockTypes.PrintMetadata);
+	for (const header of metadataBlocks) {
+		const blockData = await getBlockData(fileHandle, header);
+		extractMetadataFromText(decompressBlock(header.compression, blockData).toString("utf8"), metadata);
+	}
+	return metadata;
 }
 const METADATA_KEY_NORMALIZATION = {
-    'producer': 'producer',
-    'produced on': 'produced_on',
-    'print time': 'print_time',
-    'estimated printing time (silent mode)': 'estimated_printing_time_silent_mode',
-    'estimated printing time (normal mode)': 'estimated_printing_time_normal_mode',
-    'layer height': 'layer_height',
-    'first layer height': 'first_layer_height',
-    'initial layer height': 'initial_layer_height',
-    'nozzle diameter': 'nozzle_diameter',
-    'filament diameter': 'filament_diameter',
-    'filament density': 'filament_density',
-    'filament used [mm]': 'filament_used_mm',
-    'filament used [cm3]': 'filament_used_cm3',
-    'filament used [g]': 'filament_used_g',
-    'bed temperature': 'bed_temperature',
-    'temperature': 'temperature',
-    'fill density': 'fill_density',
-    'filament type': 'filament_type',
-    'printer model': 'printer_model',
-    'max layer z': 'max_layer_z',
-    'total layers': 'total_layers',
-    'layer count': 'layer_count'
+	producer: "producer",
+	"produced on": "produced_on",
+	"print time": "print_time",
+	"estimated printing time (silent mode)": "estimated_printing_time_silent_mode",
+	"estimated printing time (normal mode)": "estimated_printing_time_normal_mode",
+	"layer height": "layer_height",
+	"first layer height": "first_layer_height",
+	"initial layer height": "initial_layer_height",
+	"nozzle diameter": "nozzle_diameter",
+	"filament diameter": "filament_diameter",
+	"filament density": "filament_density",
+	"filament used [mm]": "filament_used_mm",
+	"filament used [cm3]": "filament_used_cm3",
+	"filament used [g]": "filament_used_g",
+	"bed temperature": "bed_temperature",
+	temperature: "temperature",
+	"fill density": "fill_density",
+	"filament type": "filament_type",
+	"printer model": "printer_model",
+	"max layer z": "max_layer_z",
+	"total layers": "total_layers",
+	"layer count": "layer_count"
 };
 function extractMetadataFromText(text, metadata) {
-    const lines = text.split('\n');
-    for (const line of lines){
-        const keyValuePair = parseMetadataLine(line);
-        if (!keyValuePair) {
-            continue;
-        }
-        const { key, value } = keyValuePair;
-        metadata[key] = value;
-    }
+	const lines = text.split("\n");
+	for (const line of lines) {
+		const keyValuePair = parseMetadataLine(line);
+		if (!keyValuePair) continue;
+		const { key, value } = keyValuePair;
+		metadata[key] = value;
+	}
 }
 function parseMetadataLine(line) {
-    const equalIndex = line.indexOf('=');
-    if (equalIndex === -1) {
-        return null;
-    }
-    const rawKey = line.substring(0, equalIndex).trim().toLowerCase();
-    const value = line.substring(equalIndex + 1).trim();
-    if (!rawKey || !value) {
-        return null;
-    }
-    const normalizedKey = METADATA_KEY_NORMALIZATION[rawKey] || rawKey.replace(/\s+/g, '_');
-    return {
-        key: normalizedKey,
-        value
-    };
+	const equalIndex = line.indexOf("=");
+	if (equalIndex === -1) return null;
+	const rawKey = line.substring(0, equalIndex).trim().toLowerCase();
+	const value = line.substring(equalIndex + 1).trim();
+	if (!rawKey || !value) return null;
+	return {
+		key: METADATA_KEY_NORMALIZATION[rawKey] || rawKey.replace(/\s+/g, "_"),
+		value
+	};
 }
+//#endregion
+export { decompressBlock, extractMetadataFromBlocks, getBlockData, getBlockParsedParameters, parseBlockHeader, parseBlockHeaders, parseBlockParameters, parseFileHeader };
 
 //# sourceMappingURL=bgcode.utils.js.map

package/dist/utils/bgcode/bgcode.utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/bgcode/bgcode.utils.ts"],"names":["decompressBlock","extractMetadataFromBlocks","getBlockData","getBlockParsedParameters","parseBlockHeader","parseBlockHeaders","parseBlockParameters","parseFileHeader","fileHandle","buffer","Buffer","alloc","BGCODE_HEADER_SIZE","read","length","Error","magic","toString","BGCODE_HEADER_MARKER","version","readUInt32LE","checksumType","readUInt16LE","fileSize","skipGcode","offset","blockHeaders","currentExpectedHeaderIndex","blockHeader","type","BgCodeBlockTypes","GCode","expectedType","BGCODE_EXPECTED_HEADERS","nextExpectedType","Number","isNaN","blockSize","push","blockStartOffset","BGCODE_MAX_BLOCK_HEADER_SIZE","position","BGCODE_MAX_BLOCK_TYPE","compression","BGCODE_MAX_COMPRESSION","uncompressedSize","compressedSize","headerSize","BGCODE_MIN_BLOCK_HEADER_SIZE","BgCodeCompressionName","checksumSize","calculateChecksumSize","calculateBlockSize","parameterOffset","parametersSize","calculateParameterSize","parameterBuffer","parameters","dataOffset","dataSize","checksumOffset","data","info","BgCodeCompressionInfo","kind","inflateSync","decoder","HeatshrinkDecoder","window","lookahead","decompress","blockType","parameterSize","BgCodeBlockParameterSizes","Thumbnail","format","calculateThumbnailFormat","width","height","encoding","BGCODE_MAX_CHECKSUM_TYPE","BgCodeChecksumTypeSize","formatParameter","BGCODE_PARAMETER_THUMBNAIL_MAX_FORMAT","metadata","metadataBlocks","filter","b","FileMetadata","SlicerMetadata","PrinterMetadata","PrintMetadata","header","blockData","text","extractMetadataFromText","METADATA_KEY_NORMALIZATION","lines","split","line","keyValuePair","parseMetadataLine","key","value","equalIndex","indexOf","rawKey","substring","trim","toLowerCase","normalizedKey","replace"],"mappings":"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"}
+{"version":3,"file":"bgcode.utils.js","names":[],"sources":["../../../src/utils/bgcode/bgcode.utils.ts"],"sourcesContent":["import {\n  BGCODE_EXPECTED_HEADERS,\n  BGCODE_HEADER_MARKER,\n  BGCODE_HEADER_SIZE,\n  BGCODE_MAX_BLOCK_HEADER_SIZE,\n  BGCODE_MAX_BLOCK_TYPE,\n  BGCODE_MAX_CHECKSUM_TYPE,\n  BGCODE_MAX_COMPRESSION,\n  BGCODE_MIN_BLOCK_HEADER_SIZE,\n  BGCODE_PARAMETER_THUMBNAIL_MAX_FORMAT,\n} from \"./bgcode.constants\";\nimport { FileHandle } from \"node:fs/promises\";\nimport {\n  type BgCodeBlockHeader,\n  type BgCodeBlockType,\n  type BgCodeHeaderSize,\n  type BgCodeChecksumType,\n  BgCodeBlockTypes,\n  BgCodeCompression,\n  BgCodeCompressionInfo,\n  BgCodeCompressionName,\n  BgCodeChecksumTypeSize,\n  BgCodeBlockParameterSizes,\n} from \"./bgcode.types\";\nimport { inflateSync } from \"node:zlib\";\nimport { HeatshrinkDecoder } from \"./heatshrink-decoder\";\n\nexport async function parseFileHeader(fileHandle: FileHandle): Promise<{\n  magic: string;\n  version: number;\n  checksumType: number;\n}> {\n  const buffer = Buffer.alloc(BGCODE_HEADER_SIZE);\n  await fileHandle.read(buffer);\n\n  if (buffer.length < BGCODE_HEADER_SIZE) {\n    throw new Error(\"File too small to be a valid BGCode file\");\n  }\n\n  const magic = buffer.toString(\"ascii\", 0, 4);\n  if (magic !== BGCODE_HEADER_MARKER) {\n    throw new Error(`Invalid BGCode file: magic number not found (got \"${magic}\", expected ${BGCODE_HEADER_MARKER})`);\n  }\n\n  const version = buffer.readUInt32LE(4);\n  const checksumType = buffer.readUInt16LE(8);\n\n  return { magic, version, checksumType };\n}\n\nexport async function parseBlockHeaders(\n  fileHandle: FileHandle,\n  fileSize: number,\n  checksumType: number,\n  skipGcode: true,\n) {\n  let offset = BGCODE_HEADER_SIZE;\n  const blockHeaders: BgCodeBlockHeader[] = [];\n  let currentExpectedHeaderIndex = 0;\n\n  while (offset < fileSize) {\n    const blockHeader = await parseBlockHeader(fileHandle, fileSize, offset, checksumType);\n    if (skipGcode && blockHeader.type == BgCodeBlockTypes.GCode) {\n      break;\n    }\n\n    const expectedType = BGCODE_EXPECTED_HEADERS[currentExpectedHeaderIndex];\n    if (blockHeader.type !== expectedType) {\n      const nextExpectedType = BGCODE_EXPECTED_HEADERS[currentExpectedHeaderIndex + 1];\n      if (blockHeader.type !== nextExpectedType) {\n        throw new Error(\n          `Unexpected header header type ${blockHeader.type}, expected either ${expectedType} or next ${nextExpectedType}`,\n        );\n      }\n      currentExpectedHeaderIndex++;\n    }\n\n    if (Number.isNaN(blockHeader.blockSize)) {\n      throw new Error(`Unexpected blockHeader.blockSize ${blockHeader.blockSize}`);\n    }\n\n    offset += blockHeader.blockSize;\n    blockHeaders.push(blockHeader);\n  }\n\n  return blockHeaders;\n}\n\nexport async function parseBlockHeader(\n  fileHandle: FileHandle,\n  fileSize: number,\n  blockStartOffset: number,\n  checksumType: BgCodeChecksumType,\n): Promise<BgCodeBlockHeader> {\n  if (blockStartOffset + BGCODE_MAX_BLOCK_HEADER_SIZE > fileSize) {\n    throw new Error(\"Not enough data for block header\");\n  }\n\n  const buffer = Buffer.alloc(BGCODE_MAX_BLOCK_HEADER_SIZE);\n  await fileHandle.read({\n    buffer,\n    offset: 0,\n    length: BGCODE_MAX_BLOCK_HEADER_SIZE,\n    position: blockStartOffset,\n  });\n\n  const type = buffer.readUInt16LE(0) as BgCodeBlockType;\n  if (type > BGCODE_MAX_BLOCK_TYPE) {\n    throw new Error(`Block header type ${type} exceeds ${BGCODE_MAX_BLOCK_TYPE}, cant parse block`);\n  }\n\n  const compression = buffer.readUInt16LE(2) as BgCodeCompression;\n  if (compression > BGCODE_MAX_COMPRESSION) {\n    throw new Error(`Block header compression ${compression} exceeds ${BGCODE_MAX_COMPRESSION}, cant parse block`);\n  }\n\n  const uncompressedSize = buffer.readUInt32LE(4);\n  if (uncompressedSize === 0) {\n    throw new Error(`Uncompressed Size is 0`);\n  }\n\n  let compressedSize = 0;\n  let headerSize = BGCODE_MIN_BLOCK_HEADER_SIZE as BgCodeHeaderSize;\n  if (compression > 0) {\n    compressedSize = buffer.readUInt32LE(8);\n    if (compressedSize === 0) {\n      throw new Error(`Compression is ${BgCodeCompressionName[compression]} but compressed size is ${compressedSize}}`);\n    }\n    headerSize = BGCODE_MAX_BLOCK_HEADER_SIZE;\n  }\n\n  const checksumSize = calculateChecksumSize(checksumType);\n  const blockSize = calculateBlockSize(checksumSize, type, compression, uncompressedSize, compressedSize);\n  const parameterOffset = blockStartOffset + headerSize;\n  const parametersSize = calculateParameterSize(type);\n  const parameterBuffer = await getBlockParsedParameters(fileHandle, parameterOffset, parametersSize);\n  const parameters = parseBlockParameters(type, parameterBuffer);\n  const dataOffset = parameterOffset + parametersSize;\n  const dataSize = blockSize - parametersSize - checksumSize;\n  const checksumOffset = dataOffset + dataSize;\n\n  return {\n    type,\n    compression,\n    uncompressedSize,\n    compressedSize,\n    blockSize,\n    blockStartOffset,\n    headerSize,\n    parameterOffset,\n    parameters,\n    parametersSize,\n    dataOffset,\n    dataSize,\n    checksumOffset,\n    checksumSize,\n    checksumType,\n  };\n}\n\nexport async function getBlockParsedParameters(\n  fileHandle: FileHandle,\n  parameterOffset: number,\n  parametersSize: number,\n) {\n  const parameters = Buffer.alloc(parametersSize);\n  if (parametersSize > 0) {\n    await fileHandle.read({ buffer: parameters, offset: 0, length: parametersSize, position: parameterOffset });\n  }\n\n  return parameters;\n}\n\nexport async function getBlockData(fileHandle: FileHandle, blockHeader: BgCodeBlockHeader) {\n  if (blockHeader.blockSize === 0) {\n    throw new Error(\"Cant get block data for block with size 0\");\n  }\n  if (blockHeader.blockSize === 1e3) {\n    throw new Error(`Cant get block data for block with size ${blockHeader.blockSize} > ${1e3}`);\n  }\n\n  const data = Buffer.alloc(blockHeader.dataSize);\n  await fileHandle.read({ buffer: data, offset: 0, length: blockHeader.dataSize, position: blockHeader.dataOffset });\n  return data;\n}\n\nexport function decompressBlock(compression: BgCodeCompression, data: Buffer) {\n  const info = BgCodeCompressionInfo[compression];\n\n  switch (info.kind) {\n    case \"none\":\n      return data;\n    case \"deflate\":\n      return inflateSync(data);\n    case \"heatshrink\":\n      const decoder = new HeatshrinkDecoder(info.window, info.lookahead);\n      return decoder.decompress(data);\n    default:\n      throw new Error(`Unknown compression type: ${compression}`);\n  }\n}\n\nexport function parseBlockParameters(blockType: BgCodeBlockType, parameters: Buffer) {\n  const parameterSize = BgCodeBlockParameterSizes[blockType];\n  if (parameters.length !== parameterSize) {\n    throw new Error(`Block Parameters should be exactly ${parameterSize} bytes long`);\n  }\n\n  if (blockType === BgCodeBlockTypes.Thumbnail) {\n    return {\n      format: calculateThumbnailFormat(parameters.readUInt16LE(0)),\n      width: parameters.readUInt16LE(2),\n      height: parameters.readUInt16LE(4),\n    };\n  }\n\n  return {\n    encoding: parameters.readUInt16LE(0),\n  };\n}\n\nfunction calculateBlockSize(\n  checksumSize: number,\n  blockType: BgCodeBlockType,\n  compression: BgCodeCompression,\n  uncompressedSize: number,\n  compressedSize: number,\n) {\n  const headerSize = compression > 0 ? 12 : 8;\n  const dataSize = compression === 0 ? uncompressedSize : compressedSize;\n  // Thumbnail type (5) has 3 fields of 2 bytes each\n  const parametersSize = blockType === BgCodeBlockTypes.Thumbnail ? 6 : 2;\n\n  return headerSize + parametersSize + dataSize + checksumSize;\n}\n\nfunction calculateChecksumSize(checksumType: BgCodeChecksumType) {\n  if (checksumType > BGCODE_MAX_CHECKSUM_TYPE) {\n    throw new Error(`Checksum type ${checksumType} exceeds max ${BGCODE_MAX_CHECKSUM_TYPE}`);\n  }\n\n  return BgCodeChecksumTypeSize[checksumType];\n}\n\nfunction calculateParameterSize(blockType: BgCodeBlockType) {\n  if (blockType > BGCODE_MAX_BLOCK_TYPE) {\n    throw new Error(`Checksum type ${blockType} exceeds max ${BGCODE_MAX_BLOCK_TYPE}`);\n  }\n\n  return BgCodeBlockParameterSizes[blockType];\n}\n\nfunction calculateThumbnailFormat(formatParameter: number) {\n  if (formatParameter > BGCODE_PARAMETER_THUMBNAIL_MAX_FORMAT) {\n    throw new Error(`Thumbnail format type ${formatParameter} exceeds max ${BGCODE_PARAMETER_THUMBNAIL_MAX_FORMAT}`);\n  }\n  return formatParameter;\n}\n\nexport async function extractMetadataFromBlocks(\n  fileHandle: FileHandle,\n  blockHeaders: BgCodeBlockHeader[],\n): Promise<Record<string, string>> {\n  const metadata: Record<string, string> = {};\n\n  const metadataBlocks = blockHeaders.filter(\n    (b) =>\n      b.type === BgCodeBlockTypes.FileMetadata ||\n      b.type === BgCodeBlockTypes.SlicerMetadata ||\n      b.type === BgCodeBlockTypes.PrinterMetadata ||\n      b.type === BgCodeBlockTypes.PrintMetadata,\n  );\n\n  for (const header of metadataBlocks) {\n    const blockData = await getBlockData(fileHandle, header);\n    const data = decompressBlock(header.compression, blockData);\n    const text = data.toString(\"utf8\");\n    extractMetadataFromText(text, metadata);\n  }\n\n  return metadata;\n}\n\nconst METADATA_KEY_NORMALIZATION: Record<string, string> = {\n  producer: \"producer\",\n  \"produced on\": \"produced_on\",\n  \"print time\": \"print_time\",\n  \"estimated printing time (silent mode)\": \"estimated_printing_time_silent_mode\",\n  \"estimated printing time (normal mode)\": \"estimated_printing_time_normal_mode\",\n  \"layer height\": \"layer_height\",\n  \"first layer height\": \"first_layer_height\",\n  \"initial layer height\": \"initial_layer_height\",\n  \"nozzle diameter\": \"nozzle_diameter\",\n  \"filament diameter\": \"filament_diameter\",\n  \"filament density\": \"filament_density\",\n  \"filament used [mm]\": \"filament_used_mm\",\n  \"filament used [cm3]\": \"filament_used_cm3\",\n  \"filament used [g]\": \"filament_used_g\",\n  \"bed temperature\": \"bed_temperature\",\n  temperature: \"temperature\",\n  \"fill density\": \"fill_density\",\n  \"filament type\": \"filament_type\",\n  \"printer model\": \"printer_model\",\n  \"max layer z\": \"max_layer_z\",\n  \"total layers\": \"total_layers\",\n  \"layer count\": \"layer_count\",\n};\n\nfunction extractMetadataFromText(text: string, metadata: Record<string, string>): void {\n  const lines = text.split(\"\\n\");\n\n  for (const line of lines) {\n    const keyValuePair = parseMetadataLine(line);\n    if (!keyValuePair) {\n      continue;\n    }\n\n    const { key, value } = keyValuePair;\n    metadata[key] = value;\n  }\n}\n\nfunction parseMetadataLine(line: string): { key: string; value: string } | null {\n  const equalIndex = line.indexOf(\"=\");\n  if (equalIndex === -1) {\n    return null;\n  }\n\n  const rawKey = line.substring(0, equalIndex).trim().toLowerCase();\n  const value = line.substring(equalIndex + 1).trim();\n\n  if (!rawKey || !value) {\n    return null;\n  }\n\n  const normalizedKey = METADATA_KEY_NORMALIZATION[rawKey] || rawKey.replace(/\\s+/g, \"_\");\n  return { key: normalizedKey, value };\n}\n"],"mappings":"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"}