@sqaitech/shared 0.30.10

package/dist/es/img/box-select.mjs

@@ -0,0 +1,184 @@
+import node_assert from "node:assert";
+import get_jimp from "./get-jimp.mjs";
+import { bufferFromBase64, imageInfoOfBase64 } from "./index.mjs";
+let cachedFont = null;
+const loadFonts = async ()=>{
+    const Jimp = await get_jimp();
+    try {
+        const fonts = await Jimp.loadFont(Jimp.FONT_SANS_16_WHITE);
+        return fonts;
+    } catch (error) {
+        console.warn('Error loading font, will try to load online fonts', error);
+        const onlineFonts = 'https://cdn.jsdelivr.net/npm/jimp-compact@0.16.1-2/fonts/open-sans/open-sans-16-white/open-sans-16-white.fnt';
+        const fonts = await Jimp.loadFont(onlineFonts);
+        return fonts;
+    }
+};
+const createSvgOverlay = async (elements, imageWidth, imageHeight, boxPadding = 5, borderThickness = 2, prompt)=>{
+    const Jimp = await get_jimp();
+    const image = new Jimp(imageWidth, imageHeight, 0x00000000);
+    const colors = [
+        {
+            rect: 0xc62300ff,
+            text: 0xffffffff
+        },
+        {
+            rect: 0x0000ffff,
+            text: 0xffffffff
+        },
+        {
+            rect: 0x8b4513ff,
+            text: 0xffffffff
+        },
+        {
+            rect: 0x3e7b27ff,
+            text: 0xffffffff
+        },
+        {
+            rect: 0x500073ff,
+            text: 0xffffffff
+        }
+    ];
+    if (prompt) try {
+        cachedFont = cachedFont || await loadFonts();
+        const promptPadding = 10;
+        const promptMargin = 20;
+        const promptHeight = 30;
+        const promptY = imageHeight - promptHeight - promptMargin;
+        image.scan(0, promptY, imageWidth, promptHeight, (x, y, idx)=>{
+            image.bitmap.data[idx + 0] = 0x00;
+            image.bitmap.data[idx + 1] = 0x00;
+            image.bitmap.data[idx + 2] = 0x00;
+            image.bitmap.data[idx + 3] = 0xcc;
+        });
+        image.print(cachedFont, promptPadding, promptY, {
+            text: prompt,
+            alignmentX: Jimp.HORIZONTAL_ALIGN_LEFT,
+            alignmentY: Jimp.VERTICAL_ALIGN_MIDDLE
+        }, imageWidth - 2 * promptPadding, promptHeight);
+    } catch (error) {
+        console.error('Error drawing prompt text', error);
+    }
+    for(let index = 0; index < elements.length; index++){
+        const element = elements[index];
+        const color = colors[index % colors.length];
+        const paddedLeft = Math.max(0, element.rect.left - boxPadding);
+        const paddedTop = Math.max(0, element.rect.top - boxPadding);
+        const paddedWidth = Math.min(imageWidth - paddedLeft, element.rect.width + 2 * boxPadding);
+        const paddedHeight = Math.min(imageHeight - paddedTop, element.rect.height + 2 * boxPadding);
+        const paddedRect = {
+            left: paddedLeft,
+            top: paddedTop,
+            width: paddedWidth,
+            height: paddedHeight
+        };
+        image.scan(paddedRect.left, paddedRect.top, paddedRect.width, paddedRect.height, (x, y, idx)=>{
+            if (x >= paddedRect.left && x < paddedRect.left + borderThickness || x <= paddedRect.left + paddedRect.width - 1 && x > paddedRect.left + paddedRect.width - borderThickness || y >= paddedRect.top && y < paddedRect.top + borderThickness || y <= paddedRect.top + paddedRect.height - 1 && y > paddedRect.top + paddedRect.height - borderThickness) {
+                image.bitmap.data[idx + 0] = color.rect >> 24 & 0xff;
+                image.bitmap.data[idx + 1] = color.rect >> 16 & 0xff;
+                image.bitmap.data[idx + 2] = color.rect >> 8 & 0xff;
+                image.bitmap.data[idx + 3] = 0xff & color.rect;
+            }
+        });
+        const indexId = element.indexId;
+        if ('number' != typeof indexId) continue;
+        const textWidth = 8 * indexId.toString().length;
+        const textHeight = 12;
+        const rectWidth = textWidth + 5;
+        const rectHeight = textHeight + 4;
+        let rectX = paddedRect.left - rectWidth;
+        let rectY = paddedRect.top + paddedRect.height / 2 - textHeight / 2 - 2;
+        const checkOverlap = (x, y)=>elements.slice(0, index).some((otherElement)=>x < otherElement.rect.left + otherElement.rect.width && x + rectWidth > otherElement.rect.left && y < otherElement.rect.top + otherElement.rect.height && y + rectHeight > otherElement.rect.top);
+        const isWithinBounds = (x, y)=>x >= 0 && x + rectWidth <= imageWidth && y >= 0 && y + rectHeight <= imageHeight;
+        if (checkOverlap(rectX, rectY) || !isWithinBounds(rectX, rectY)) if (!checkOverlap(paddedRect.left, paddedRect.top - rectHeight - 2) && isWithinBounds(paddedRect.left, paddedRect.top - rectHeight - 2)) {
+            rectX = paddedRect.left;
+            rectY = paddedRect.top - rectHeight - 2;
+        } else if (!checkOverlap(paddedRect.left, paddedRect.top + paddedRect.height + 2) && isWithinBounds(paddedRect.left, paddedRect.top + paddedRect.height + 2)) {
+            rectX = paddedRect.left;
+            rectY = paddedRect.top + paddedRect.height + 2;
+        } else if (!checkOverlap(paddedRect.left + paddedRect.width + 2, paddedRect.top) && isWithinBounds(paddedRect.left + paddedRect.width + 2, paddedRect.top)) {
+            rectX = paddedRect.left + paddedRect.width + 2;
+            rectY = paddedRect.top;
+        } else {
+            rectX = paddedRect.left;
+            rectY = paddedRect.top + 2;
+        }
+        image.scan(rectX, rectY, rectWidth, rectHeight, (x, y, idx)=>{
+            image.bitmap.data[idx + 0] = color.rect >> 24 & 0xff;
+            image.bitmap.data[idx + 1] = color.rect >> 16 & 0xff;
+            image.bitmap.data[idx + 2] = color.rect >> 8 & 0xff;
+            image.bitmap.data[idx + 3] = 0xff & color.rect;
+        });
+        try {
+            cachedFont = cachedFont || await loadFonts();
+        } catch (error) {
+            console.error('Error loading font', error);
+        }
+        image.print(cachedFont, rectX, rectY, {
+            text: indexId.toString(),
+            alignmentX: Jimp.HORIZONTAL_ALIGN_CENTER,
+            alignmentY: Jimp.VERTICAL_ALIGN_MIDDLE
+        }, rectWidth, rectHeight);
+    }
+    return image;
+};
+const compositeElementInfoImg = async (options)=>{
+    node_assert(options.inputImgBase64, 'inputImgBase64 is required');
+    let width = 0;
+    let height = 0;
+    let jimpImage;
+    const Jimp = await get_jimp();
+    if (options.size) {
+        width = options.size.width;
+        height = options.size.height;
+    }
+    if (width && height) {
+        const imageBuffer = await bufferFromBase64(options.inputImgBase64);
+        jimpImage = await Jimp.read(imageBuffer);
+        const imageBitmap = jimpImage.bitmap;
+        if (imageBitmap.width !== width || imageBitmap.height !== height) jimpImage.resize(width, height, Jimp.RESIZE_NEAREST_NEIGHBOR);
+    } else {
+        const info = await imageInfoOfBase64(options.inputImgBase64);
+        width = info.width;
+        height = info.height;
+        jimpImage = info.jimpImage;
+    }
+    if (!width || !height) throw Error('Image processing failed because width or height is undefined');
+    const { elementsPositionInfo, prompt } = options;
+    const result = await Promise.resolve(jimpImage).then(async (image)=>{
+        const svgOverlay = await createSvgOverlay(elementsPositionInfo, width, height, options.annotationPadding, options.borderThickness, prompt);
+        const svgImage = await Jimp.read(svgOverlay);
+        const compositeImage = await image.composite(svgImage, 0, 0, {
+            mode: Jimp.BLEND_SOURCE_OVER,
+            opacitySource: 1,
+            opacityDest: 1
+        });
+        return compositeImage;
+    }).then(async (compositeImage)=>{
+        compositeImage.quality(90);
+        const base64 = await compositeImage.getBase64Async(Jimp.MIME_JPEG);
+        return base64;
+    }).catch((error)=>{
+        throw error;
+    });
+    return result;
+};
+const processImageElementInfo = async (options)=>{
+    const base64Image = options.inputImgBase64.split(';base64,').pop();
+    node_assert(base64Image, 'base64Image is undefined');
+    const [compositeElementInfoImgBase64, compositeElementInfoImgWithoutTextBase64] = await Promise.all([
+        compositeElementInfoImg({
+            inputImgBase64: options.inputImgBase64,
+            elementsPositionInfo: options.elementsPositionInfo
+        }),
+        compositeElementInfoImg({
+            inputImgBase64: options.inputImgBase64,
+            elementsPositionInfo: options.elementsPositionInfoWithoutText
+        })
+    ]);
+    return {
+        compositeElementInfoImgBase64,
+        compositeElementInfoImgWithoutTextBase64
+    };
+};
+export { compositeElementInfoImg, processImageElementInfo };

package/dist/es/img/draw-box.mjs

@@ -0,0 +1,42 @@
+import get_jimp from "./get-jimp.mjs";
+import { bufferFromBase64 } from "./info.mjs";
+import { saveBase64Image } from "./transform.mjs";
+async function drawBoxOnImage(options) {
+    const { inputImgBase64, rect } = options;
+    const color = {
+        r: 255,
+        g: 0,
+        b: 0,
+        a: 255
+    };
+    const Jimp = await get_jimp();
+    const imageBuffer = await bufferFromBase64(inputImgBase64);
+    const image = await Jimp.read(imageBuffer);
+    const centerX = rect.x;
+    const centerY = rect.y;
+    const radius = 5;
+    image.scan(Math.floor(centerX - radius), Math.floor(centerY - radius), 2 * radius, 2 * radius, (x, y, idx)=>{
+        const distance = Math.sqrt((x - centerX) ** 2 + (y - centerY) ** 2);
+        if (distance <= radius) {
+            image.bitmap.data[idx + 0] = color.r;
+            image.bitmap.data[idx + 1] = color.g;
+            image.bitmap.data[idx + 2] = color.b;
+            image.bitmap.data[idx + 3] = color.a;
+        }
+    });
+    image.quality(90);
+    const resultBase64 = await image.getBase64Async(Jimp.MIME_JPEG);
+    return resultBase64;
+}
+async function savePositionImg(options) {
+    const { inputImgBase64, rect, outputPath } = options;
+    const imgBase64 = await drawBoxOnImage({
+        inputImgBase64,
+        rect
+    });
+    await saveBase64Image({
+        base64Data: imgBase64,
+        outputPath
+    });
+}
+export { drawBoxOnImage, savePositionImg };

package/dist/es/img/get-jimp.mjs

@@ -0,0 +1,10 @@
+import jimp from "jimp";
+import { ifInBrowser, ifInWorker } from "../utils.mjs";
+async function getJimp() {
+    if (ifInBrowser || ifInWorker) {
+        await import("jimp/browser/lib/jimp.js");
+        return ('undefined' != typeof window ? window : self).Jimp;
+    }
+    return jimp;
+}
+export { getJimp as default };

package/dist/es/img/get-photon.mjs

@@ -0,0 +1,19 @@
+import { ifInBrowser, ifInNode, ifInWorker } from "../utils.mjs";
+let photonModule = null;
+let isInitialized = false;
+async function getPhoton() {
+    if (photonModule && isInitialized) return photonModule;
+    try {
+        if (ifInBrowser || ifInWorker) {
+            const photon = await import("@silvia-odwyer/photon");
+            if ('function' == typeof photon.default) await photon.default();
+            photonModule = photon;
+        } else if (ifInNode) photonModule = await import("@silvia-odwyer/photon-node");
+        if (!photonModule.PhotonImage || !photonModule.PhotonImage.new_from_byteslice) throw new Error('PhotonImage.new_from_byteslice is not available');
+        isInitialized = true;
+        return photonModule;
+    } catch (error) {
+        throw new Error(`Failed to load photon module: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export { getPhoton as default };

package/dist/es/img/get-sharp.mjs

@@ -0,0 +1,11 @@
+import { ifInNode } from "../utils.mjs";
+async function getSharp() {
+    if (!ifInNode) throw new Error('Sharp is only available in Node.js environment');
+    try {
+        const sharp = await import("sharp");
+        return sharp.default;
+    } catch (error) {
+        throw new Error(`Failed to load sharp module: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export { getSharp as default };

package/dist/es/img/index.mjs

@@ -0,0 +1,5 @@
+import { bufferFromBase64, imageInfo, imageInfoOfBase64, isValidPNGImageBuffer } from "./info.mjs";
+import { createImgBase64ByFormat, cropByRect, httpImg2Base64, jimpFromBase64, jimpToBase64, localImg2Base64, paddingToMatchBlock, paddingToMatchBlockByBase64, parseBase64, preProcessImageUrl, resizeAndConvertImgBuffer, resizeImgBase64, saveBase64Image, zoomForGPT4o } from "./transform.mjs";
+import { compositeElementInfoImg, processImageElementInfo } from "./box-select.mjs";
+import { drawBoxOnImage, savePositionImg } from "./draw-box.mjs";
+export { bufferFromBase64, compositeElementInfoImg, createImgBase64ByFormat, cropByRect, drawBoxOnImage, httpImg2Base64, imageInfo, imageInfoOfBase64, isValidPNGImageBuffer, jimpFromBase64, jimpToBase64, localImg2Base64, paddingToMatchBlock, paddingToMatchBlockByBase64, parseBase64, preProcessImageUrl, processImageElementInfo, resizeAndConvertImgBuffer, resizeImgBase64, saveBase64Image, savePositionImg, zoomForGPT4o };

package/dist/es/img/info.mjs

@@ -0,0 +1,32 @@
+import node_assert from "node:assert";
+import { Buffer } from "node:buffer";
+import get_jimp from "./get-jimp.mjs";
+async function imageInfo(image) {
+    const Jimp = await get_jimp();
+    let jimpImage;
+    if ('string' == typeof image) jimpImage = await Jimp.read(image);
+    else if (Buffer.isBuffer(image)) jimpImage = await Jimp.read(image);
+    else if (image instanceof Jimp) jimpImage = image;
+    else throw new Error('Invalid image input: must be a string path or a Buffer');
+    const { width, height } = jimpImage.bitmap;
+    node_assert(width && height, `Invalid image: ${'string' == typeof image ? image : 'Buffer'}`);
+    return {
+        width,
+        height,
+        jimpImage
+    };
+}
+async function imageInfoOfBase64(imageBase64) {
+    const buffer = await bufferFromBase64(imageBase64);
+    return imageInfo(buffer);
+}
+async function bufferFromBase64(imageBase64) {
+    const base64Data = imageBase64.replace(/^data:image\/\w+;base64,/, '');
+    return Buffer.from(base64Data, 'base64');
+}
+function isValidPNGImageBuffer(buffer) {
+    if (!buffer || buffer.length < 8) return false;
+    const isPNG = 0x89 === buffer[0] && 0x50 === buffer[1] && 0x4e === buffer[2] && 0x47 === buffer[3];
+    return isPNG;
+}
+export { bufferFromBase64, imageInfo, imageInfoOfBase64, isValidPNGImageBuffer };

package/dist/es/img/transform.mjs

@@ -0,0 +1,192 @@
+import node_assert from "node:assert";
+import { Buffer } from "node:buffer";
+import { readFileSync } from "node:fs";
+import node_path from "node:path";
+import { getDebug } from "../logger.mjs";
+import { ifInNode } from "../utils.mjs";
+import get_jimp from "./get-jimp.mjs";
+import get_photon from "./get-photon.mjs";
+import get_sharp from "./get-sharp.mjs";
+const imgDebug = getDebug('img');
+async function saveBase64Image(options) {
+    const { base64Data, outputPath } = options;
+    const { body } = parseBase64(base64Data);
+    const imageBuffer = Buffer.from(body, 'base64');
+    const Jimp = await get_jimp();
+    const image = await Jimp.read(imageBuffer);
+    await image.writeAsync(outputPath);
+}
+async function resizeAndConvertImgBuffer(inputFormat, inputData, newSize) {
+    if ('string' == typeof inputData) throw Error('inputData is base64, use resizeImgBase64 instead');
+    node_assert(newSize && newSize.width > 0 && newSize.height > 0, 'newSize must be positive');
+    const resizeStartTime = Date.now();
+    imgDebug(`resizeImg start, target size: ${newSize.width}x${newSize.height}`);
+    if (ifInNode) try {
+        const Sharp = await get_sharp();
+        const metadata = await Sharp(inputData).metadata();
+        const { width: originalWidth, height: originalHeight } = metadata;
+        if (!originalWidth || !originalHeight) throw Error('Undefined width or height from the input image.');
+        if (newSize.width === originalWidth && newSize.height === originalHeight) return {
+            buffer: inputData,
+            format: inputFormat
+        };
+        const resizedBuffer = await Sharp(inputData).resize(newSize.width, newSize.height).jpeg({
+            quality: 90
+        }).toBuffer();
+        const resizeEndTime = Date.now();
+        imgDebug(`resizeImg done (Sharp), target size: ${newSize.width}x${newSize.height}, cost: ${resizeEndTime - resizeStartTime}ms`);
+        return {
+            buffer: resizedBuffer,
+            format: 'jpeg'
+        };
+    } catch (error) {
+        imgDebug('Sharp failed, falling back to Photon:', error);
+    }
+    const { PhotonImage, SamplingFilter, resize } = await get_photon();
+    const inputBytes = new Uint8Array(inputData);
+    const inputImage = PhotonImage.new_from_byteslice(inputBytes);
+    const originalWidth = inputImage.get_width();
+    const originalHeight = inputImage.get_height();
+    if (!originalWidth || !originalHeight) {
+        inputImage.free();
+        throw Error('Undefined width or height from the input image.');
+    }
+    if (newSize.width === originalWidth && newSize.height === originalHeight) {
+        inputImage.free();
+        return {
+            buffer: inputData,
+            format: inputFormat
+        };
+    }
+    const outputImage = resize(inputImage, newSize.width, newSize.height, SamplingFilter.CatmullRom);
+    const outputBytes = outputImage.get_bytes_jpeg(90);
+    const resizedBuffer = Buffer.from(outputBytes);
+    inputImage.free();
+    outputImage.free();
+    const resizeEndTime = Date.now();
+    imgDebug(`resizeImg done (Photon), target size: ${newSize.width}x${newSize.height}, cost: ${resizeEndTime - resizeStartTime}ms`);
+    return {
+        buffer: resizedBuffer,
+        format: 'jpeg'
+    };
+}
+const createImgBase64ByFormat = (format, body)=>`data:image/${format};base64,${body}`;
+async function resizeImgBase64(inputBase64, newSize) {
+    const { body, mimeType } = parseBase64(inputBase64);
+    const imageBuffer = Buffer.from(body, 'base64');
+    const { buffer, format } = await resizeAndConvertImgBuffer(mimeType.split('/')[1], imageBuffer, newSize);
+    return createImgBase64ByFormat(format, buffer.toString('base64'));
+}
+function zoomForGPT4o(originalWidth, originalHeight) {
+    const maxWidth = 2048;
+    const maxHeight = 768;
+    let newWidth = originalWidth;
+    let newHeight = originalHeight;
+    const aspectRatio = originalWidth / originalHeight;
+    if (originalWidth > maxWidth) {
+        newWidth = maxWidth;
+        newHeight = newWidth / aspectRatio;
+    }
+    if (newHeight > maxHeight) {
+        newHeight = maxHeight;
+        newWidth = newHeight * aspectRatio;
+    }
+    return {
+        width: Math.round(newWidth),
+        height: Math.round(newHeight)
+    };
+}
+async function jimpFromBase64(base64) {
+    const Jimp = await get_jimp();
+    const { body } = parseBase64(base64);
+    const imageBuffer = Buffer.from(body, 'base64');
+    return Jimp.read(imageBuffer);
+}
+async function paddingToMatchBlock(image, blockSize = 28) {
+    const { width, height } = image.bitmap;
+    const targetWidth = Math.ceil(width / blockSize) * blockSize;
+    const targetHeight = Math.ceil(height / blockSize) * blockSize;
+    if (targetWidth === width && targetHeight === height) return {
+        width,
+        height,
+        image
+    };
+    const Jimp = await get_jimp();
+    const paddedImage = new Jimp(targetWidth, targetHeight, 0xffffffff);
+    paddedImage.composite(image, 0, 0);
+    return {
+        width: targetWidth,
+        height: targetHeight,
+        image: paddedImage
+    };
+}
+async function paddingToMatchBlockByBase64(imageBase64, blockSize = 28) {
+    const jimpImage = await jimpFromBase64(imageBase64);
+    const paddedResult = await paddingToMatchBlock(jimpImage, blockSize);
+    return {
+        width: paddedResult.width,
+        height: paddedResult.height,
+        imageBase64: await jimpToBase64(paddedResult.image)
+    };
+}
+async function cropByRect(imageBase64, rect, paddingImage) {
+    const jimpImage = await jimpFromBase64(imageBase64);
+    const { left, top, width, height } = rect;
+    jimpImage.crop(left, top, width, height);
+    if (paddingImage) {
+        const paddedResult = await paddingToMatchBlock(jimpImage);
+        return {
+            width: paddedResult.width,
+            height: paddedResult.height,
+            imageBase64: await jimpToBase64(paddedResult.image)
+        };
+    }
+    return {
+        width: jimpImage.bitmap.width,
+        height: jimpImage.bitmap.height,
+        imageBase64: await jimpToBase64(jimpImage)
+    };
+}
+async function jimpToBase64(image) {
+    const Jimp = await get_jimp();
+    return image.getBase64Async(Jimp.MIME_JPEG);
+}
+const httpImg2Base64 = async (url)=>{
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`Failed to fetch image: ${url}`);
+    const contentType = response.headers.get('content-type');
+    if (!contentType) throw new Error(`Failed to fetch image: ${url}`);
+    node_assert(contentType.startsWith('image/'), `The url ${url} is not a image, because of content-type in header is ${contentType}.`);
+    const buffer = Buffer.from(await response.arrayBuffer());
+    return `data:${contentType};base64,${buffer.toString('base64')}`;
+};
+const localImg2Base64 = (imgPath, withoutHeader = false)=>{
+    const body = readFileSync(imgPath).toString('base64');
+    if (withoutHeader) return body;
+    const type = node_path.extname(imgPath).slice(1);
+    const finalType = 'svg' === type ? 'svg+xml' : type || 'jpg';
+    return `data:image/${finalType};base64,${body}`;
+};
+const preProcessImageUrl = async (url, convertHttpImage2Base64)=>{
+    if ('string' != typeof url) throw new Error(`url must be a string, but got ${url} with type ${typeof url}`);
+    if (url.startsWith('data:')) return url;
+    if (!(url.startsWith('http://') || url.startsWith('https://'))) return await localImg2Base64(url);
+    if (!convertHttpImage2Base64) return url;
+    return await httpImg2Base64(url);
+};
+const parseBase64 = (fullBase64String)=>{
+    try {
+        const separator = ';base64,';
+        const index = fullBase64String.indexOf(separator);
+        if (-1 === index) throw new Error('Invalid base64 string');
+        return {
+            mimeType: fullBase64String.slice(5, index),
+            body: fullBase64String.slice(index + separator.length)
+        };
+    } catch (e) {
+        throw new Error(`parseBase64 fail because intput is not a valid base64 string: ${fullBase64String}`, {
+            cause: e
+        });
+    }
+};
+export { createImgBase64ByFormat, cropByRect, httpImg2Base64, jimpFromBase64, jimpToBase64, localImg2Base64, paddingToMatchBlock, paddingToMatchBlockByBase64, parseBase64, preProcessImageUrl, resizeAndConvertImgBuffer, resizeImgBase64, saveBase64Image, zoomForGPT4o };

package/dist/es/index.mjs

@@ -0,0 +1,3 @@
+import { createCopyStaticPlugin, createPlaygroundCopyPlugin } from "./build/copy-static.mjs";
+const src = {};
+export { createCopyStaticPlugin, createPlaygroundCopyPlugin, src as default };

package/dist/es/logger.mjs

@@ -0,0 +1,61 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import node_util from "node:util";
+import debug from "debug";
+import { getMidsceneRunSubDir } from "./common.mjs";
+import { ifInNode } from "./utils.mjs";
+const topicPrefix = 'midscene';
+const logStreams = new Map();
+const debugInstances = new Map();
+function getLogStream(topic) {
+    const topicFileName = topic.replace(/:/g, '-');
+    if (!logStreams.has(topicFileName)) {
+        const logFile = node_path.join(getMidsceneRunSubDir('log'), `${topicFileName}.log`);
+        const stream = node_fs.createWriteStream(logFile, {
+            flags: 'a'
+        });
+        logStreams.set(topicFileName, stream);
+    }
+    return logStreams.get(topicFileName);
+}
+function writeLogToFile(topic, message) {
+    if (!ifInNode) return;
+    const stream = getLogStream(topic);
+    const now = new Date();
+    const isoDate = now.toLocaleDateString('sv-SE');
+    const isoTime = now.toLocaleTimeString('sv-SE');
+    const milliseconds = now.getMilliseconds().toString().padStart(3, '0');
+    const timezoneOffsetMinutes = now.getTimezoneOffset();
+    const sign = timezoneOffsetMinutes <= 0 ? '+' : '-';
+    const hours = Math.floor(Math.abs(timezoneOffsetMinutes) / 60).toString().padStart(2, '0');
+    const minutes = (Math.abs(timezoneOffsetMinutes) % 60).toString().padStart(2, '0');
+    const timezoneString = `${sign}${hours}:${minutes}`;
+    const localISOTime = `${isoDate}T${isoTime}.${milliseconds}${timezoneString}`;
+    stream.write(`[${localISOTime}] ${message}\n`);
+}
+function getDebug(topic) {
+    const fullTopic = `${topicPrefix}:${topic}`;
+    if (!debugInstances.has(fullTopic)) {
+        const debugFn = debug(fullTopic);
+        const wrapper = (...args)=>{
+            if (ifInNode) {
+                const message = node_util.format(...args);
+                writeLogToFile(topic, message);
+            }
+            debugFn(...args);
+        };
+        debugInstances.set(fullTopic, wrapper);
+    }
+    return debugInstances.get(fullTopic);
+}
+function enableDebug(topic) {
+    if (ifInNode) return;
+    debug.enable(`${topicPrefix}:${topic}`);
+}
+function cleanupLogStreams() {
+    if (!ifInNode) return;
+    for (const stream of logStreams.values())stream.end();
+    logStreams.clear();
+    debugInstances.clear();
+}
+export { cleanupLogStreams, enableDebug, getDebug };