brilliantsole 0.0.36 → 0.0.37

package/build/brilliantsole.node.module.d.ts

@@ -1800,36 +1800,6 @@ declare function simplifyCurves(curves: DisplayBezierCurve[], epsilon?: number):
 declare function simplifyPoints(points: Vector2[], tolerance?: number): Vector2[];
 declare function simplifyPointsAsCubicCurveControlPoints(points: Vector2[], error?: number): Vector2[];
 
-declare function quantizeImage(image: HTMLImageElement, width: number, height: number, numberOfColors: number, colors?: string[], canvas?: HTMLCanvasElement): Promise<{
-    blob: Blob;
-    colors: string[];
-    colorIndices: number[];
-}>;
-declare function resizeImage(image: CanvasImageSource, width: number, height: number, canvas?: HTMLCanvasElement): HTMLCanvasElement;
-declare function resizeAndQuantizeImage(image: CanvasImageSource, width: number, height: number, numberOfColors: number, colors?: string[], canvas?: HTMLCanvasElement): Promise<{
-    blob: Blob;
-    colors: string[];
-    colorIndices: number[];
-}>;
-declare function canvasToBitmaps(canvas: HTMLCanvasElement, numberOfColors: number, mtu: number): Promise<{
-    bitmapRows: DisplayBitmap[][];
-    colors: string[];
-}>;
-declare function imageToBitmaps(image: HTMLImageElement, width: number, height: number, numberOfColors: number, mtu: number): Promise<{
-    bitmapRows: DisplayBitmap[][];
-    colors: string[];
-}>;
-declare function canvasToSprite(canvas: HTMLCanvasElement, spriteName: string, numberOfColors: number, paletteName: string, overridePalette: boolean, spriteSheet: DisplaySpriteSheet, paletteOffset?: number): Promise<{
-    sprite: DisplaySprite;
-    blob: Blob;
-}>;
-declare function imageToSprite(image: HTMLImageElement, spriteName: string, width: number, height: number, numberOfColors: number, paletteName: string, overridePalette: boolean, spriteSheet: DisplaySpriteSheet, paletteOffset?: number): Promise<{
-    sprite: DisplaySprite;
-    blob: Blob;
-}>;
-declare function canvasToSpriteSheet(canvas: HTMLCanvasElement, spriteSheetName: string, numberOfColors: number, paletteName: string, maxFileLength?: number): Promise<DisplaySpriteSheet>;
-declare function imageToSpriteSheet(image: HTMLImageElement, spriteSheetName: string, width: number, height: number, numberOfColors: number, paletteName: string, maxFileLength?: number): Promise<DisplaySpriteSheet>;
-
 declare function hexToRGB(hex: string): DisplayColorRGB;
 declare function rgbToHex({ r, g, b }: DisplayColorRGB): string;
 
@@ -2063,5 +2033,5 @@ declare const ThrottleUtils: {
     debounce: typeof debounce;
 };
 
-export { CameraCommands, CameraConfigurationTypes, ContinuousSensorTypes, DefaultNumberOfDisplayColors, DefaultNumberOfPressureSensors, Device, _default as DeviceManager, DevicePair, DevicePairTypes, DeviceTypes, DisplayAlignments, DisplayBezierCurveTypes, DisplayBrightnesses, DisplayContextCommandTypes, DisplayDirections, DisplayPixelDepths, DisplaySegmentCaps, DisplaySpriteContextCommandTypes, environment_d as Environment, EventUtils, FileTransferDirections, FileTypes, MaxNameLength, MaxNumberOfVibrationWaveformEffectSegments, MaxNumberOfVibrationWaveformSegments, MaxSensorRate, MaxSpriteSheetNameLength, MaxVibrationWaveformEffectSegmentDelay, MaxVibrationWaveformEffectSegmentLoopCount, MaxVibrationWaveformEffectSequenceLoopCount, MaxVibrationWaveformSegmentDuration, MaxWifiPasswordLength, MaxWifiSSIDLength, MicrophoneCommands, MicrophoneConfigurationTypes, MicrophoneConfigurationValues, MinNameLength, MinSpriteSheetNameLength, MinWifiPasswordLength, MinWifiSSIDLength, RangeHelper, scanner as Scanner, SensorRateStep, SensorTypes, Sides, TfliteSensorTypes, TfliteTasks, ThrottleUtils, Timer, UDPServer, VibrationLocations, VibrationTypes, VibrationWaveformEffects, WebSocketServer, canvasToBitmaps, canvasToSprite, canvasToSpriteSheet, displayCurveTypeToNumberOfControlPoints, englishRegex, fontToSpriteSheet, getFontMaxHeight, getFontMetrics, getFontUnicodeRange, getMaxSpriteSheetSize, hexToRGB, imageToBitmaps, imageToSprite, imageToSpriteSheet, intersectWireframes, isWireframePolygon, maxDisplayScale, mergeWireframes, parseFont, pixelDepthToNumberOfColors, quantizeImage, resizeAndQuantizeImage, resizeImage, rgbToHex, setAllConsoleLevelFlags, setConsoleLevelFlagsForType, simplifyCurves, simplifyPoints, simplifyPointsAsCubicCurveControlPoints, stringToSprites, wait };
+export { CameraCommands, CameraConfigurationTypes, ContinuousSensorTypes, DefaultNumberOfDisplayColors, DefaultNumberOfPressureSensors, Device, _default as DeviceManager, DevicePair, DevicePairTypes, DeviceTypes, DisplayAlignments, DisplayBezierCurveTypes, DisplayBrightnesses, DisplayContextCommandTypes, DisplayDirections, DisplayPixelDepths, DisplaySegmentCaps, DisplaySpriteContextCommandTypes, environment_d as Environment, EventUtils, FileTransferDirections, FileTypes, MaxNameLength, MaxNumberOfVibrationWaveformEffectSegments, MaxNumberOfVibrationWaveformSegments, MaxSensorRate, MaxSpriteSheetNameLength, MaxVibrationWaveformEffectSegmentDelay, MaxVibrationWaveformEffectSegmentLoopCount, MaxVibrationWaveformEffectSequenceLoopCount, MaxVibrationWaveformSegmentDuration, MaxWifiPasswordLength, MaxWifiSSIDLength, MicrophoneCommands, MicrophoneConfigurationTypes, MicrophoneConfigurationValues, MinNameLength, MinSpriteSheetNameLength, MinWifiPasswordLength, MinWifiSSIDLength, RangeHelper, scanner as Scanner, SensorRateStep, SensorTypes, Sides, TfliteSensorTypes, TfliteTasks, ThrottleUtils, Timer, UDPServer, VibrationLocations, VibrationTypes, VibrationWaveformEffects, WebSocketServer, displayCurveTypeToNumberOfControlPoints, englishRegex, fontToSpriteSheet, getFontMaxHeight, getFontMetrics, getFontUnicodeRange, getMaxSpriteSheetSize, hexToRGB, intersectWireframes, isWireframePolygon, maxDisplayScale, mergeWireframes, parseFont, pixelDepthToNumberOfColors, rgbToHex, setAllConsoleLevelFlags, setConsoleLevelFlagsForType, simplifyCurves, simplifyPoints, simplifyPointsAsCubicCurveControlPoints, stringToSprites, wait };
 export type { BoundDeviceEventListeners, BoundDeviceManagerEventListeners, BoundDevicePairEventListeners, CameraCommand, CameraConfiguration, CameraConfigurationType, CenterOfPressure, ContinuousSensorType, DeviceEvent, DeviceEventListenerMap, DeviceEventMap, DeviceInformation, DeviceManagerEvent, DeviceManagerEventListenerMap, DeviceManagerEventMap, DevicePairEvent, DevicePairEventListenerMap, DevicePairEventMap, DevicePairType, DeviceType, DiscoveredDevice, DisplayAlignment, DisplayBezierCurveType, DisplayBitmap, DisplayBitmapColorPair, DisplayBrightness, DisplayColorRGB, DisplayContextCommand, DisplayContextCommandType, DisplayDirection, DisplaySegmentCap, DisplaySize, DisplaySprite, DisplaySpriteColorPair, DisplaySpriteContextCommandType, DisplaySpriteLine, DisplaySpriteLines, DisplaySpritePaletteSwap, DisplaySpriteSheet, DisplaySpriteSheetPalette, DisplaySpriteSubLine, DisplayWireframe, DisplayWireframeEdge, Euler, FileTransferDirection, FileType, FontToSpriteSheetOptions, MicrophoneCommand, MicrophoneConfiguration, MicrophoneConfigurationType, PressureData, Quaternion, Range, SensorConfiguration, SensorType, Side, TfliteFileConfiguration, TfliteSensorType, TfliteTask, Vector2, Vector3, VibrationConfiguration, VibrationLocation, VibrationType, VibrationWaveformEffect };

package/build/brilliantsole.node.module.js

@@ -5587,9 +5587,6 @@ function removeSubstrings(string, substrings) {
 
 const _console$r = createConsole("DisplaySpriteSheetUtils", { log: false });
 const spriteHeaderLength = 3 * 2;
-function calculateSpriteSheetHeaderLength(numberOfSprites) {
-    return 2 + numberOfSprites * 2 + numberOfSprites * spriteHeaderLength;
-}
 function getCurvesPoints(curves) {
     const curvePoints = [];
     curves.forEach((curve, index) => {
@@ -6369,15 +6366,6 @@ function resizeImage(image, width, height, canvas) {
     ctx.drawImage(image, 0, 0, width, height);
     return canvas;
 }
-function cropCanvas(canvas, x, y, width, height, targetCanvas) {
-    targetCanvas = targetCanvas || document.createElement("canvas");
-    const ctx = targetCanvas.getContext("2d", { willReadFrequently: true });
-    targetCanvas.width = width;
-    targetCanvas.height = height;
-    ctx.imageSmoothingEnabled = false;
-    ctx.drawImage(canvas, x, y, width, height, 0, 0, width, height);
-    return targetCanvas;
-}
 function removeAlphaFromCanvas(canvas) {
     const ctx = canvas.getContext("2d", { willReadFrequently: true });
     const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
@@ -6416,77 +6404,6 @@ async function imageToBitmap(image, width, height, colors, bitmapColorIndices, n
     };
     return { blob, bitmap };
 }
-const drawSpriteBitmapCommandHeaderLength = 1 + 2 + 2 + 2 + 2 + 1 + 2;
-async function canvasToBitmaps(canvas, numberOfColors, mtu) {
-    const { blob, colors, colorIndices } = await quantizeCanvas(canvas, numberOfColors);
-    const bitmapRows = [];
-    const { width, height } = canvas;
-    const numberOfPixels = width * height;
-    const pixelDepth = DisplayPixelDepths.find((pixelDepth) => pixelDepthToNumberOfColors(pixelDepth) >= numberOfColors);
-    _console$q.assertWithError(pixelDepth, `no pixelDepth found that covers ${numberOfColors} colors`);
-    const pixelsPerByte = pixelDepthToPixelsPerByte(pixelDepth);
-    const numberOfBytes = Math.ceil(numberOfPixels / pixelsPerByte);
-    _console$q.log({
-        width,
-        height,
-        numberOfPixels,
-        pixelDepth,
-        pixelsPerByte,
-        numberOfBytes,
-        mtu,
-    });
-    const maxPixelDataLength = mtu - (drawSpriteBitmapCommandHeaderLength + 5);
-    const maxPixels = Math.floor(maxPixelDataLength / pixelsPerByte);
-    const maxBitmapWidth = Math.min(maxPixels, width);
-    let maxBitmapHeight = 1;
-    if (maxBitmapWidth == width) {
-        const bitmapRowPixelDataLength = Math.ceil(width / pixelsPerByte);
-        maxBitmapHeight = Math.floor(maxPixelDataLength / bitmapRowPixelDataLength);
-    }
-    _console$q.log({
-        maxPixelDataLength,
-        maxPixels,
-        maxBitmapHeight,
-        maxBitmapWidth,
-    });
-    if (maxBitmapHeight >= height) {
-        _console$q.log("image is small enough for a single bitmap");
-        const bitmap = {
-            numberOfColors,
-            pixels: colorIndices,
-            width,
-            height,
-        };
-        bitmapRows.push([bitmap]);
-    }
-    else {
-        let offsetX = 0;
-        let offsetY = 0;
-        const bitmapCanvas = document.createElement("canvas");
-        const bitmapColorIndices = new Array(numberOfColors)
-            .fill(0)
-            .map((_, i) => i);
-        while (offsetY < height) {
-            const bitmapHeight = Math.min(maxBitmapHeight, height - offsetY);
-            offsetX = 0;
-            const bitmapRow = [];
-            bitmapRows.push(bitmapRow);
-            while (offsetX < width) {
-                const bitmapWidth = Math.min(maxBitmapWidth, width - offsetX);
-                cropCanvas(canvas, offsetX, offsetY, bitmapWidth, bitmapHeight, bitmapCanvas);
-                const { bitmap } = await imageToBitmap(bitmapCanvas, bitmapWidth, bitmapHeight, colors, bitmapColorIndices, numberOfColors);
-                bitmapRow.push(bitmap);
-                offsetX += bitmapWidth;
-            }
-            offsetY += bitmapHeight;
-        }
-    }
-    return { bitmapRows, colors };
-}
-async function imageToBitmaps(image, width, height, numberOfColors, mtu) {
-    const canvas = resizeImage(image, width, height);
-    return canvasToBitmaps(canvas, numberOfColors, mtu);
-}
 function getBitmapNumberOfBytes(bitmap) {
     const pixelDepth = numberOfColorsToPixelDepth(bitmap.numberOfColors);
     const pixelsPerByte = pixelDepthToPixelsPerByte(pixelDepth);
@@ -6506,127 +6423,6 @@ function assertValidBitmapPixels(bitmap) {
         _console$q.assertRangeWithError(`bitmap.pixels[${index}]`, pixel, 0, bitmap.numberOfColors - 1);
     });
 }
-async function canvasToSprite(canvas, spriteName, numberOfColors, paletteName, overridePalette, spriteSheet, paletteOffset = 0) {
-    const { width, height } = canvas;
-    let palette = spriteSheet.palettes?.find((palette) => palette.name == paletteName);
-    if (!palette) {
-        palette = {
-            name: paletteName,
-            numberOfColors,
-            colors: new Array(numberOfColors).fill("#000000"),
-        };
-        spriteSheet.palettes = spriteSheet.palettes || [];
-        spriteSheet.palettes?.push(palette);
-    }
-    _console$q.log("pallete", palette);
-    const sprite = {
-        name: spriteName,
-        width,
-        height,
-        paletteSwaps: [],
-        commands: [],
-    };
-    const results = await quantizeCanvas(canvas, numberOfColors, !overridePalette ? palette.colors : undefined);
-    const blob = results.blob;
-    const colorIndices = results.colorIndices;
-    if (overridePalette) {
-        results.colors.forEach((color, index) => {
-            palette.colors[index + paletteOffset] = color;
-        });
-    }
-    sprite.commands.push({
-        type: "selectBitmapColors",
-        bitmapColorPairs: new Array(numberOfColors).fill(0).map((_, index) => ({
-            bitmapColorIndex: index,
-            colorIndex: index + paletteOffset,
-        })),
-    });
-    const bitmap = {
-        numberOfColors,
-        pixels: colorIndices,
-        width,
-        height,
-    };
-    sprite.commands.push({ type: "drawBitmap", offsetX: 0, offsetY: 0, bitmap });
-    const spriteIndex = spriteSheet.sprites.findIndex((sprite) => sprite.name == spriteName);
-    if (spriteIndex == -1) {
-        spriteSheet.sprites.push(sprite);
-    }
-    else {
-        _console$q.log(`overwriting spriteIndex ${spriteIndex}`);
-        spriteSheet.sprites[spriteIndex] = sprite;
-    }
-    return { sprite, blob };
-}
-async function imageToSprite(image, spriteName, width, height, numberOfColors, paletteName, overridePalette, spriteSheet, paletteOffset = 0) {
-    const canvas = resizeImage(image, width, height);
-    return canvasToSprite(canvas, spriteName, numberOfColors, paletteName, overridePalette, spriteSheet, paletteOffset);
-}
-const spriteSheetWithSingleBitmapCommandLength = calculateSpriteSheetHeaderLength(1) + drawSpriteBitmapCommandHeaderLength;
-function spriteSheetWithBitmapCommandAndSelectBitmapColorsLength(numberOfColors) {
-    return (spriteSheetWithSingleBitmapCommandLength + (1 + 1 + numberOfColors * 2));
-}
-async function canvasToSpriteSheet(canvas, spriteSheetName, numberOfColors, paletteName, maxFileLength) {
-    const spriteSheet = {
-        name: spriteSheetName,
-        palettes: [],
-        paletteSwaps: [],
-        sprites: [],
-    };
-    if (maxFileLength == undefined) {
-        await canvasToSprite(canvas, "image", numberOfColors, paletteName, true, spriteSheet);
-    }
-    else {
-        const { width, height } = canvas;
-        const numberOfPixels = width * height;
-        const pixelDepth = DisplayPixelDepths.find((pixelDepth) => pixelDepthToNumberOfColors(pixelDepth) >= numberOfColors);
-        _console$q.assertWithError(pixelDepth, `no pixelDepth found that covers ${numberOfColors} colors`);
-        const pixelsPerByte = pixelDepthToPixelsPerByte(pixelDepth);
-        const numberOfBytes = Math.ceil(numberOfPixels / pixelsPerByte);
-        _console$q.log({
-            width,
-            height,
-            numberOfPixels,
-            pixelDepth,
-            pixelsPerByte,
-            numberOfBytes,
-            maxFileLength,
-        });
-        const maxPixelDataLength = maxFileLength -
-            (spriteSheetWithBitmapCommandAndSelectBitmapColorsLength(numberOfColors) +
-                5);
-        const imageRowPixelDataLength = Math.ceil(width / pixelsPerByte);
-        const maxSpriteHeight = Math.floor(maxPixelDataLength / imageRowPixelDataLength);
-        if (maxSpriteHeight >= height) {
-            _console$q.log("image is small enough for a single sprite");
-            await canvasToSprite(canvas, "image", numberOfColors, paletteName, true, spriteSheet);
-        }
-        else {
-            const { colors } = await quantizeCanvas(canvas, numberOfColors);
-            spriteSheet.palettes?.push({ name: paletteName, numberOfColors, colors });
-            let offsetY = 0;
-            let imageIndex = 0;
-            const spriteCanvas = document.createElement("canvas");
-            while (offsetY < height) {
-                const spriteHeight = Math.min(maxSpriteHeight, height - offsetY);
-                cropCanvas(canvas, 0, offsetY, width, spriteHeight, spriteCanvas);
-                offsetY += spriteHeight;
-                _console$q.log(`cropping sprite ${imageIndex}`, {
-                    offsetY,
-                    width,
-                    spriteHeight,
-                });
-                await canvasToSprite(spriteCanvas, `image${imageIndex}`, numberOfColors, paletteName, false, spriteSheet);
-                imageIndex++;
-            }
-        }
-    }
-    return spriteSheet;
-}
-async function imageToSpriteSheet(image, spriteSheetName, width, height, numberOfColors, paletteName, maxFileLength) {
-    const canvas = resizeImage(image, width, height);
-    return canvasToSpriteSheet(canvas, spriteSheetName, numberOfColors, paletteName, maxFileLength);
-}
 
 const _console$p = createConsole("DisplayManagerInterface", { log: false });
 async function runDisplayContextCommand(displayManager, command, sendImmediately) {
@@ -14592,5 +14388,5 @@ const ThrottleUtils = {
     debounce,
 };
 
-export { CameraCommands, CameraConfigurationTypes, ContinuousSensorTypes, DefaultNumberOfDisplayColors, DefaultNumberOfPressureSensors, Device, DeviceManager$1 as DeviceManager, DevicePair, DevicePairTypes, DeviceTypes, DisplayAlignments, DisplayBezierCurveTypes, DisplayBrightnesses, DisplayContextCommandTypes, DisplayDirections, DisplayPixelDepths, DisplaySegmentCaps, DisplaySpriteContextCommandTypes, environment as Environment, EventUtils, FileTransferDirections, FileTypes, MaxNameLength, MaxNumberOfVibrationWaveformEffectSegments, MaxNumberOfVibrationWaveformSegments, MaxSensorRate, MaxSpriteSheetNameLength, MaxVibrationWaveformEffectSegmentDelay, MaxVibrationWaveformEffectSegmentLoopCount, MaxVibrationWaveformEffectSequenceLoopCount, MaxVibrationWaveformSegmentDuration, MaxWifiPasswordLength, MaxWifiSSIDLength, MicrophoneCommands, MicrophoneConfigurationTypes, MicrophoneConfigurationValues, MinNameLength, MinSpriteSheetNameLength, MinWifiPasswordLength, MinWifiSSIDLength, RangeHelper, scanner$1 as Scanner, SensorRateStep, SensorTypes, Sides, TfliteSensorTypes, TfliteTasks, ThrottleUtils, Timer, UDPServer, VibrationLocations, VibrationTypes, VibrationWaveformEffects, WebSocketServer, canvasToBitmaps, canvasToSprite, canvasToSpriteSheet, displayCurveTypeToNumberOfControlPoints, englishRegex, fontToSpriteSheet, getFontMaxHeight, getFontMetrics, getFontUnicodeRange, getMaxSpriteSheetSize, hexToRGB, imageToBitmaps, imageToSprite, imageToSpriteSheet, intersectWireframes, isWireframePolygon, maxDisplayScale, mergeWireframes, parseFont, pixelDepthToNumberOfColors, quantizeImage, resizeAndQuantizeImage, resizeImage, rgbToHex, setAllConsoleLevelFlags, setConsoleLevelFlagsForType, simplifyCurves, simplifyPoints, simplifyPointsAsCubicCurveControlPoints, stringToSprites, wait };
+export { CameraCommands, CameraConfigurationTypes, ContinuousSensorTypes, DefaultNumberOfDisplayColors, DefaultNumberOfPressureSensors, Device, DeviceManager$1 as DeviceManager, DevicePair, DevicePairTypes, DeviceTypes, DisplayAlignments, DisplayBezierCurveTypes, DisplayBrightnesses, DisplayContextCommandTypes, DisplayDirections, DisplayPixelDepths, DisplaySegmentCaps, DisplaySpriteContextCommandTypes, environment as Environment, EventUtils, FileTransferDirections, FileTypes, MaxNameLength, MaxNumberOfVibrationWaveformEffectSegments, MaxNumberOfVibrationWaveformSegments, MaxSensorRate, MaxSpriteSheetNameLength, MaxVibrationWaveformEffectSegmentDelay, MaxVibrationWaveformEffectSegmentLoopCount, MaxVibrationWaveformEffectSequenceLoopCount, MaxVibrationWaveformSegmentDuration, MaxWifiPasswordLength, MaxWifiSSIDLength, MicrophoneCommands, MicrophoneConfigurationTypes, MicrophoneConfigurationValues, MinNameLength, MinSpriteSheetNameLength, MinWifiPasswordLength, MinWifiSSIDLength, RangeHelper, scanner$1 as Scanner, SensorRateStep, SensorTypes, Sides, TfliteSensorTypes, TfliteTasks, ThrottleUtils, Timer, UDPServer, VibrationLocations, VibrationTypes, VibrationWaveformEffects, WebSocketServer, displayCurveTypeToNumberOfControlPoints, englishRegex, fontToSpriteSheet, getFontMaxHeight, getFontMetrics, getFontUnicodeRange, getMaxSpriteSheetSize, hexToRGB, intersectWireframes, isWireframePolygon, maxDisplayScale, mergeWireframes, parseFont, pixelDepthToNumberOfColors, rgbToHex, setAllConsoleLevelFlags, setConsoleLevelFlagsForType, simplifyCurves, simplifyPoints, simplifyPointsAsCubicCurveControlPoints, stringToSprites, wait };
 //# sourceMappingURL=brilliantsole.node.module.js.map