coding-usage-bar 0.2.2 → 0.2.3

package/dist/menubar-render.d.ts

@@ -0,0 +1,67 @@
+export interface TitleSegment {
+    provider: string;
+    bars: Array<{
+        pct: number;
+        lightColor: string;
+        darkColor: string;
+    }>;
+    iconPath: string | null;
+    iconPathDark: string | null;
+}
+export interface TitleVariant {
+    dividerColor: string;
+    dividerAlpha: number;
+    barBgColor: string;
+    barBgAlpha: number;
+}
+export interface TitlePayload {
+    segments: TitleSegment[];
+    scale: number;
+    height: number;
+    minWidth: number;
+    paddingX: number;
+    iconSize: number;
+    iconBarGap: number;
+    segmentGap: number;
+    barWidth: number;
+    barHeight: number;
+    barGap: number;
+    barRadius: number;
+    barMinFill: number;
+    light: TitleVariant;
+    dark: TitleVariant;
+}
+interface RenderedImage {
+    image: string;
+    width: number;
+    height: number;
+}
+export declare function renderTitleImage(payload: TitlePayload): {
+    light: RenderedImage;
+    dark: RenderedImage;
+};
+export interface DropdownPayload {
+    bars: Array<{
+        pct: number;
+        lightColor: string;
+        darkColor: string;
+    }>;
+    scale: number;
+    barWidth: number;
+    barHeight: number;
+    barRadius: number;
+    light: {
+        barBgColor: string;
+        barBgAlpha: number;
+    };
+    dark: {
+        barBgColor: string;
+        barBgAlpha: number;
+    };
+}
+export declare function renderDropdownBars(payload: DropdownPayload): {
+    images: string[];
+    width: number;
+    height: number;
+};
+export {};

package/dist/menubar-render.js

@@ -0,0 +1,255 @@
+import fs from "node:fs";
+import { encodePNG, decodePNG } from "./png.js";
+// Pure-JS reimplementation of the menu bar image rendering that previously ran
+// through `osascript -l JavaScript` + AppKit. Spawning AppKit-linked processes
+// connects to the WindowServer and stalls the whole display for 1-2s on every
+// SwiftBar refresh; drawing the pixels in-process here never touches the
+// WindowServer, so there is zero UI freeze. Geometry, colors and the y-up
+// (bottom-left origin) coordinate system mirror the old AppKit code exactly so
+// the rendered images stay visually identical.
+const SUPERSAMPLE = 4; // 4x4 coverage sampling for anti-aliased rounded corners
+function parseHex(hex) {
+    const v = hex.replace("#", "");
+    return {
+        r: parseInt(v.slice(0, 2), 16) / 255,
+        g: parseInt(v.slice(2, 4), 16) / 255,
+        b: parseInt(v.slice(4, 6), 16) / 255,
+    };
+}
+class Canvas {
+    width;
+    height;
+    data; // straight-alpha RGBA, 0..1
+    constructor(width, height) {
+        this.width = width;
+        this.height = height;
+        this.data = new Float32Array(width * height * 4);
+    }
+    // Source-over compositing of a single pixel using straight alpha.
+    composite(px, py, color, alpha) {
+        if (alpha <= 0 || px < 0 || py < 0 || px >= this.width || py >= this.height) {
+            return;
+        }
+        const idx = (py * this.width + px) * 4;
+        const dr = this.data[idx];
+        const dg = this.data[idx + 1];
+        const db = this.data[idx + 2];
+        const da = this.data[idx + 3];
+        const outA = alpha + da * (1 - alpha);
+        if (outA <= 0) {
+            this.data[idx] = this.data[idx + 1] = this.data[idx + 2] = this.data[idx + 3] = 0;
+            return;
+        }
+        this.data[idx] = (color.r * alpha + dr * da * (1 - alpha)) / outA;
+        this.data[idx + 1] = (color.g * alpha + dg * da * (1 - alpha)) / outA;
+        this.data[idx + 2] = (color.b * alpha + db * da * (1 - alpha)) / outA;
+        this.data[idx + 3] = outA;
+    }
+    // Fill a rounded rectangle expressed in AppKit coordinates (origin bottom-left,
+    // y increases upward). r is clamped to half the smaller side, matching
+    // CGPathCreateWithRoundedRect.
+    fillRoundedRect(ax, ay, aw, ah, radius, color, alpha) {
+        const r = Math.min(radius, aw / 2, ah / 2);
+        const cx = ax + aw / 2;
+        const cy = ay + ah / 2;
+        const halfW = aw / 2 - r;
+        const halfH = ah / 2 - r;
+        const H = this.height;
+        const pxMin = Math.max(0, Math.floor(ax));
+        const pxMax = Math.min(this.width, Math.ceil(ax + aw));
+        const pyMin = Math.max(0, Math.floor(H - (ay + ah)));
+        const pyMax = Math.min(H, Math.ceil(H - ay));
+        for (let py = pyMin; py < pyMax; py++) {
+            for (let px = pxMin; px < pxMax; px++) {
+                let hits = 0;
+                for (let j = 0; j < SUPERSAMPLE; j++) {
+                    for (let i = 0; i < SUPERSAMPLE; i++) {
+                        const sx = px + (i + 0.5) / SUPERSAMPLE;
+                        const sPngY = py + (j + 0.5) / SUPERSAMPLE;
+                        const sy = H - sPngY; // back to AppKit y-up
+                        const qx = Math.abs(sx - cx) - halfW;
+                        const qy = Math.abs(sy - cy) - halfH;
+                        const dxo = Math.max(qx, 0);
+                        const dyo = Math.max(qy, 0);
+                        const dist = Math.sqrt(dxo * dxo + dyo * dyo) + Math.min(Math.max(qx, qy), 0) - r;
+                        if (dist <= 0)
+                            hits++;
+                    }
+                }
+                if (hits > 0) {
+                    this.composite(px, py, color, alpha * (hits / (SUPERSAMPLE * SUPERSAMPLE)));
+                }
+            }
+        }
+    }
+    // Draw an RGBA source image upright into an AppKit-space rect (bottom-left
+    // origin), bilinearly scaled to `size` x `size`. Mirrors NSImage.drawInRect.
+    drawIcon(icon, ax, ay, size) {
+        const H = this.height;
+        const pxMin = Math.max(0, Math.floor(ax));
+        const pxMax = Math.min(this.width, Math.ceil(ax + size));
+        const pyMin = Math.max(0, Math.floor(H - (ay + size)));
+        const pyMax = Math.min(H, Math.ceil(H - ay));
+        const iw = icon.width;
+        const ih = icon.height;
+        for (let py = pyMin; py < pyMax; py++) {
+            for (let px = pxMin; px < pxMax; px++) {
+                const cxA = px + 0.5;
+                const cyA = H - (py + 0.5);
+                const u = (cxA - ax) / size; // 0..1 left -> right
+                const v = (ay + size - cyA) / size; // 0..1 top -> bottom
+                if (u < 0 || u >= 1 || v < 0 || v >= 1)
+                    continue;
+                const sample = bilinear(icon.data, iw, ih, u * iw - 0.5, v * ih - 0.5);
+                if (sample.a > 0) {
+                    this.composite(px, py, { r: sample.r, g: sample.g, b: sample.b }, sample.a);
+                }
+            }
+        }
+    }
+    toPNGBase64() {
+        const out = new Uint8Array(this.width * this.height * 4);
+        for (let i = 0; i < this.width * this.height; i++) {
+            out[i * 4] = Math.round(clamp01(this.data[i * 4]) * 255);
+            out[i * 4 + 1] = Math.round(clamp01(this.data[i * 4 + 1]) * 255);
+            out[i * 4 + 2] = Math.round(clamp01(this.data[i * 4 + 2]) * 255);
+            out[i * 4 + 3] = Math.round(clamp01(this.data[i * 4 + 3]) * 255);
+        }
+        return encodePNG(out, this.width, this.height).toString("base64");
+    }
+}
+function clamp01(v) {
+    return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+function bilinear(data, w, h, fx, fy) {
+    const x0 = Math.floor(fx);
+    const y0 = Math.floor(fy);
+    const tx = fx - x0;
+    const ty = fy - y0;
+    const at = (x, y) => {
+        const cx = x < 0 ? 0 : x >= w ? w - 1 : x;
+        const cy = y < 0 ? 0 : y >= h ? h - 1 : y;
+        const idx = (cy * w + cx) * 4;
+        return {
+            r: data[idx] / 255,
+            g: data[idx + 1] / 255,
+            b: data[idx + 2] / 255,
+            a: data[idx + 3] / 255,
+        };
+    };
+    const c00 = at(x0, y0);
+    const c10 = at(x0 + 1, y0);
+    const c01 = at(x0, y0 + 1);
+    const c11 = at(x0 + 1, y0 + 1);
+    const lerp = (a, b, t) => a + (b - a) * t;
+    return {
+        r: lerp(lerp(c00.r, c10.r, tx), lerp(c01.r, c11.r, tx), ty),
+        g: lerp(lerp(c00.g, c10.g, tx), lerp(c01.g, c11.g, tx), ty),
+        b: lerp(lerp(c00.b, c10.b, tx), lerp(c01.b, c11.b, tx), ty),
+        a: lerp(lerp(c00.a, c10.a, tx), lerp(c01.a, c11.a, tx), ty),
+    };
+}
+const iconCache = new Map();
+function loadIcon(iconPath) {
+    if (iconCache.has(iconPath)) {
+        return iconCache.get(iconPath) ?? null;
+    }
+    let decoded = null;
+    try {
+        decoded = decodePNG(fs.readFileSync(iconPath));
+    }
+    catch {
+        decoded = null;
+    }
+    iconCache.set(iconPath, decoded);
+    return decoded;
+}
+function drawTitle(payload, variant, mode) {
+    const scale = payload.scale || 1;
+    const height = payload.height * scale;
+    const iconSize = payload.iconSize * scale;
+    const paddingX = payload.paddingX * scale;
+    const iconBarGap = payload.iconBarGap * scale;
+    const segmentGap = payload.segmentGap * scale;
+    const barWidth = payload.barWidth * scale;
+    const barHeight = payload.barHeight * scale;
+    const barGap = payload.barGap * scale;
+    const barRadius = payload.barRadius * scale;
+    const barMinFill = (payload.barMinFill || barRadius * 2) * scale;
+    const dividerW = 1 * scale;
+    let width = paddingX * 2;
+    payload.segments.forEach((seg, idx) => {
+        if (idx > 0)
+            width += segmentGap + dividerW + segmentGap;
+        width += (seg.iconPath ? iconSize + iconBarGap : 0) + barWidth;
+    });
+    width = Math.max(payload.minWidth * scale, width);
+    const canvas = new Canvas(Math.round(width), Math.round(height));
+    const dividerColor = parseHex(variant.dividerColor);
+    let x = paddingX;
+    const iconY = Math.floor((height - iconSize) / 2);
+    payload.segments.forEach((seg, idx) => {
+        if (idx > 0) {
+            x += segmentGap;
+            canvas.fillRoundedRect(x, Math.floor(height * 0.2), dividerW, Math.floor(height * 0.6), 0, dividerColor, variant.dividerAlpha);
+            x += dividerW + segmentGap;
+        }
+        const iconFile = mode === "dark" && seg.iconPathDark ? seg.iconPathDark : seg.iconPath;
+        if (iconFile) {
+            const icon = loadIcon(iconFile);
+            if (icon) {
+                canvas.drawIcon(icon, x, iconY, iconSize);
+            }
+            x += iconSize + iconBarGap;
+        }
+        const bars = seg.bars || [];
+        const totalH = bars.length * barHeight + Math.max(0, bars.length - 1) * barGap;
+        let barY = Math.floor((height + totalH) / 2) - barHeight;
+        const barBgColor = parseHex(variant.barBgColor);
+        for (let i = 0; i < bars.length; i++) {
+            canvas.fillRoundedRect(x, barY, barWidth, barHeight, barRadius, barBgColor, variant.barBgAlpha);
+            if (bars[i].pct > 0) {
+                const pct = Math.min(bars[i].pct, 100);
+                const fw = Math.max(barMinFill, Math.round((barWidth * pct) / 100));
+                const fillColor = parseHex(mode === "dark" ? bars[i].darkColor : bars[i].lightColor);
+                canvas.fillRoundedRect(x, barY, fw, barHeight, barRadius, fillColor, 1);
+            }
+            barY -= barHeight + barGap;
+        }
+        x += barWidth;
+    });
+    return {
+        image: canvas.toPNGBase64(),
+        width: Math.ceil(width / scale),
+        height: payload.height,
+    };
+}
+export function renderTitleImage(payload) {
+    return {
+        light: drawTitle(payload, payload.light, "light"),
+        dark: drawTitle(payload, payload.dark, "dark"),
+    };
+}
+function makeBar(bw, bh, br, pct, fill, bgColor, bgAlpha) {
+    const canvas = new Canvas(bw, bh);
+    canvas.fillRoundedRect(0, 0, bw, bh, br, bgColor, bgAlpha);
+    if (pct > 0) {
+        const fw = Math.max(br * 2, Math.round((bw * Math.min(pct, 100)) / 100));
+        canvas.fillRoundedRect(0, 0, fw, bh, br, fill, 1);
+    }
+    return canvas.toPNGBase64();
+}
+export function renderDropdownBars(payload) {
+    const s = payload.scale || 2;
+    const bw = payload.barWidth * s;
+    const bh = payload.barHeight * s;
+    const br = payload.barRadius * s;
+    const lightBg = parseHex(payload.light.barBgColor);
+    const darkBg = parseHex(payload.dark.barBgColor);
+    const images = payload.bars.map((bar) => {
+        const light = makeBar(bw, bh, br, bar.pct, parseHex(bar.lightColor), lightBg, payload.light.barBgAlpha);
+        const dark = makeBar(bw, bh, br, bar.pct, parseHex(bar.darkColor), darkBg, payload.dark.barBgAlpha);
+        return `${light},${dark}`;
+    });
+    return { images, width: payload.barWidth, height: payload.barHeight };
+}

package/dist/menubar.js

@@ -7,6 +7,7 @@ import { formatDurationUntil, formatProviderLabel } from "./format.js";
 import { buildPaths } from "./paths.js";
 import { stableNodeExecutable } from "./node-runtime.js";
 import { loadDisplayStatusSnapshot } from "./runtime.js";
+import { renderTitleImage, renderDropdownBars } from "./menubar-render.js";
 const MARKER = "coding-usage-bar managed SwiftBar plugin";
 const SWIFTBAR_APP_PATHS = ["/Applications/SwiftBar.app", path.join(process.env.HOME ?? "", "Applications", "SwiftBar.app")];
 const STATE_LABEL = {
@@ -65,154 +66,6 @@ const ASSET_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..
 const imageCache = new Map();
 const TITLE_IMAGE_SCALE = 2;
 const titleImageCache = new Map();
-const TITLE_IMAGE_SCRIPT = `
-ObjC.import('AppKit');
-ObjC.import('CoreGraphics');
-
-function drawImage(payload, variant, mode) {
-  var scale = payload.scale || 1;
-  var height = payload.height * scale;
-  var iconSize = payload.iconSize * scale;
-  var paddingX = payload.paddingX * scale;
-  var iconBarGap = payload.iconBarGap * scale;
-  var segmentGap = payload.segmentGap * scale;
-  var barWidth = payload.barWidth * scale;
-  var barHeight = payload.barHeight * scale;
-  var barGap = payload.barGap * scale;
-  var barRadius = payload.barRadius * scale;
-  var barMinFill = (payload.barMinFill || barRadius * 2) * scale;
-  var dividerW = 1 * scale;
-
-  var width = paddingX * 2;
-  payload.segments.forEach(function(seg, idx) {
-    if (idx > 0) width += segmentGap + dividerW + segmentGap;
-    width += (seg.iconPath ? iconSize + iconBarGap : 0) + barWidth;
-  });
-  width = Math.max(payload.minWidth * scale, width);
-
-  var rep = $.NSBitmapImageRep.alloc.initWithBitmapDataPlanesPixelsWidePixelsHighBitsPerSampleSamplesPerPixelHasAlphaIsPlanarColorSpaceNameBitmapFormatBytesPerRowBitsPerPixel(
-    null, width, height, 8, 4, true, false, $.NSDeviceRGBColorSpace, $.NSBitmapFormatAlphaPremultipliedLast, 0, 0
-  );
-  var nsctx = $.NSGraphicsContext.graphicsContextWithBitmapImageRep(rep);
-  $.NSGraphicsContext.setCurrentContext(nsctx);
-  nsctx.setShouldAntialias(true);
-  nsctx.setImageInterpolation($.NSImageInterpolationHigh);
-  var cg = nsctx.CGContext;
-
-  function setFill(hex, alpha) {
-    var v = hex.replace('#', '');
-    $.CGContextSetRGBFillColor(cg,
-      parseInt(v.slice(0, 2), 16) / 255,
-      parseInt(v.slice(2, 4), 16) / 255,
-      parseInt(v.slice(4, 6), 16) / 255,
-      alpha !== undefined ? alpha : 1);
-  }
-
-  function fillRoundedRect(rx, ry, rw, rh, rr) {
-    var p = $.CGPathCreateWithRoundedRect($.CGRectMake(rx, ry, rw, rh), rr, rr, null);
-    $.CGContextAddPath(cg, p);
-    $.CGContextFillPath(cg);
-  }
-
-  var x = paddingX;
-  var iconY = Math.floor((height - iconSize) / 2);
-
-  payload.segments.forEach(function(seg, idx) {
-    if (idx > 0) {
-      x += segmentGap;
-      setFill(variant.dividerColor, variant.dividerAlpha);
-      $.CGContextFillRect(cg, $.CGRectMake(x, Math.floor(height * 0.2), dividerW, Math.floor(height * 0.6)));
-      x += dividerW + segmentGap;
-    }
-    var iconFile = (mode === 'dark' && seg.iconPathDark) ? seg.iconPathDark : seg.iconPath;
-    if (iconFile) {
-      var icon = $.NSImage.alloc.initWithContentsOfFile($(iconFile));
-      if (icon) {
-        icon.drawInRectFromRectOperationFraction(
-          $.NSMakeRect(x, iconY, iconSize, iconSize),
-          $.NSZeroRect, $.NSCompositingOperationSourceOver, 1
-        );
-      }
-      x += iconSize + iconBarGap;
-    }
-    var bars = seg.bars || [];
-    var totalH = bars.length * barHeight + Math.max(0, bars.length - 1) * barGap;
-    var barY = Math.floor((height + totalH) / 2) - barHeight;
-    for (var i = 0; i < bars.length; i++) {
-      setFill(variant.barBgColor, variant.barBgAlpha);
-      fillRoundedRect(x, barY, barWidth, barHeight, barRadius);
-      if (bars[i].pct > 0) {
-        var pct = Math.min(bars[i].pct, 100);
-        var fw = Math.max(barMinFill, Math.round(barWidth * pct / 100));
-        setFill(bars[i][mode + 'Color'], 1);
-        fillRoundedRect(x, barY, fw, barHeight, barRadius);
-      }
-      barY -= barHeight + barGap;
-    }
-    x += barWidth;
-  });
-
-  var png = rep.representationUsingTypeProperties($.NSBitmapImageFileTypePNG, $.NSDictionary.alloc.init);
-  return {
-    image: ObjC.unwrap(png.base64EncodedStringWithOptions(0)),
-    width: Math.ceil(width / scale),
-    height: payload.height,
-  };
-}
-
-function run(argv) {
-  var payload = JSON.parse(argv[0]);
-  return JSON.stringify({
-    light: drawImage(payload, payload.light, 'light'),
-    dark: drawImage(payload, payload.dark, 'dark'),
-  });
-}
-`;
-const DROPDOWN_BAR_SCRIPT = `
-ObjC.import('AppKit');
-ObjC.import('CoreGraphics');
-
-function parseHex(hex) {
-  var v = hex.replace('#', '');
-  return [parseInt(v.slice(0,2),16)/255, parseInt(v.slice(2,4),16)/255, parseInt(v.slice(4,6),16)/255];
-}
-
-function makeBar(bw, bh, br, pct, fc, bgHex, bgAlpha) {
-  var rep = $.NSBitmapImageRep.alloc.initWithBitmapDataPlanesPixelsWidePixelsHighBitsPerSampleSamplesPerPixelHasAlphaIsPlanarColorSpaceNameBitmapFormatBytesPerRowBitsPerPixel(
-    null, bw, bh, 8, 4, true, false, $.NSDeviceRGBColorSpace, $.NSBitmapFormatAlphaPremultipliedLast, 0, 0);
-  var nsctx = $.NSGraphicsContext.graphicsContextWithBitmapImageRep(rep);
-  $.NSGraphicsContext.setCurrentContext(nsctx);
-  nsctx.setShouldAntialias(true);
-  var cg = nsctx.CGContext;
-  var bg = parseHex(bgHex);
-  $.CGContextSetRGBFillColor(cg, bg[0], bg[1], bg[2], bgAlpha);
-  var bp = $.CGPathCreateWithRoundedRect($.CGRectMake(0,0,bw,bh), br, br, null);
-  $.CGContextAddPath(cg, bp); $.CGContextFillPath(cg);
-  if (pct > 0) {
-    var fw = Math.max(br*2, Math.round(bw * Math.min(pct,100) / 100));
-    $.CGContextSetRGBFillColor(cg, fc[0], fc[1], fc[2], 1);
-    var fp = $.CGPathCreateWithRoundedRect($.CGRectMake(0,0,fw,bh), br, br, null);
-    $.CGContextAddPath(cg, fp); $.CGContextFillPath(cg);
-  }
-  var png = rep.representationUsingTypeProperties($.NSBitmapImageFileTypePNG, $.NSDictionary.alloc.init);
-  return ObjC.unwrap(png.base64EncodedStringWithOptions(0));
-}
-
-function run(argv) {
-  var p = JSON.parse(argv[0]);
-  var s = p.scale || 2;
-  var bw = p.barWidth * s, bh = p.barHeight * s, br = p.barRadius * s;
-  var results = [];
-  for (var i = 0; i < p.bars.length; i++) {
-    var bar = p.bars[i];
-    var lc = parseHex(bar.lightColor), dc = parseHex(bar.darkColor);
-    var li = makeBar(bw, bh, br, bar.pct, lc, p.light.barBgColor, p.light.barBgAlpha);
-    var di = makeBar(bw, bh, br, bar.pct, dc, p.dark.barBgColor, p.dark.barBgAlpha);
-    results.push(li + ',' + di);
-  }
-  return JSON.stringify({images: results, width: p.barWidth, height: p.barHeight});
-}
-`;
 const dropdownBarCache = new Map();
 function renderDropdownBarImages(bars) {
     if (bars.length === 0) {
@@ -233,11 +86,7 @@ function renderDropdownBarImages(bars) {
         return cached ? cached.images.map((img) => ({ image: img, width: cached.width, height: cached.height })) : [];
     }
     try {
-        const output = execFileSync("/usr/bin/osascript", ["-l", "JavaScript", "-e", DROPDOWN_BAR_SCRIPT, cacheKey], {
-            encoding: "utf8",
-            timeout: 3000,
-        }).trim();
-        const result = JSON.parse(output);
+        const result = renderDropdownBars(payload);
         dropdownBarCache.set(cacheKey, result);
         return result.images.map((img) => ({ image: img, width: result.width, height: result.height }));
     }
@@ -559,11 +408,7 @@ function titleImageValue(providers) {
         return titleImageCache.get(cacheKey);
     }
     try {
-        const output = execFileSync("/usr/bin/osascript", ["-l", "JavaScript", "-e", TITLE_IMAGE_SCRIPT, cacheKey], {
-            encoding: "utf8",
-            timeout: 2500,
-        }).trim();
-        const images = JSON.parse(output);
+        const images = renderTitleImage(payload);
         const value = images.light?.image && images.dark?.image && images.light.width && images.light.height
             ? {
                 image: `${images.light.image},${images.dark.image}`,

package/dist/png.d.ts

@@ -0,0 +1,7 @@
+export declare function encodePNG(rgba: Uint8Array, width: number, height: number): Buffer;
+export interface DecodedPNG {
+    width: number;
+    height: number;
+    data: Uint8Array;
+}
+export declare function decodePNG(buffer: Buffer): DecodedPNG;

package/dist/png.js

@@ -0,0 +1,141 @@
+import zlib from "node:zlib";
+// Minimal zero-dependency PNG codec, scoped to 8-bit RGBA, non-interlaced images.
+// That is the only format this tool renders (menu bar strips) and the only
+// format its provider icon assets use (all 18x18 RGBA8). Keeping the codec tiny
+// preserves the package's zero-runtime-dependency property.
+const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+const CRC_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++) {
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        }
+        table[n] = c >>> 0;
+    }
+    return table;
+})();
+function crc32(buf) {
+    let c = 0xffffffff;
+    for (let i = 0; i < buf.length; i++) {
+        c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
+    }
+    return (c ^ 0xffffffff) >>> 0;
+}
+function chunk(type, data) {
+    const typeBuf = Buffer.from(type, "ascii");
+    const len = Buffer.alloc(4);
+    len.writeUInt32BE(data.length, 0);
+    const crcBuf = Buffer.alloc(4);
+    crcBuf.writeUInt32BE(crc32(Buffer.concat([typeBuf, data])), 0);
+    return Buffer.concat([len, typeBuf, data, crcBuf]);
+}
+export function encodePNG(rgba, width, height) {
+    const stride = width * 4;
+    // One filter byte (0 = None) per scanline, followed by the raw RGBA row.
+    const raw = Buffer.alloc(height * (stride + 1));
+    for (let y = 0; y < height; y++) {
+        const dst = y * (stride + 1);
+        raw[dst] = 0;
+        for (let i = 0; i < stride; i++) {
+            raw[dst + 1 + i] = rgba[y * stride + i];
+        }
+    }
+    const ihdr = Buffer.alloc(13);
+    ihdr.writeUInt32BE(width, 0);
+    ihdr.writeUInt32BE(height, 4);
+    ihdr[8] = 8; // bit depth
+    ihdr[9] = 6; // color type: RGBA
+    ihdr[10] = 0; // compression
+    ihdr[11] = 0; // filter
+    ihdr[12] = 0; // interlace
+    const idat = zlib.deflateSync(raw, { level: 9 });
+    return Buffer.concat([
+        PNG_SIGNATURE,
+        chunk("IHDR", ihdr),
+        chunk("IDAT", idat),
+        chunk("IEND", Buffer.alloc(0)),
+    ]);
+}
+function paeth(a, b, c) {
+    const p = a + b - c;
+    const pa = Math.abs(p - a);
+    const pb = Math.abs(p - b);
+    const pc = Math.abs(p - c);
+    if (pa <= pb && pa <= pc)
+        return a;
+    if (pb <= pc)
+        return b;
+    return c;
+}
+export function decodePNG(buffer) {
+    if (!buffer.subarray(0, 8).equals(PNG_SIGNATURE)) {
+        throw new Error("decodePNG: not a PNG file");
+    }
+    let offset = 8;
+    let width = 0;
+    let height = 0;
+    const idatParts = [];
+    while (offset < buffer.length) {
+        const len = buffer.readUInt32BE(offset);
+        const type = buffer.toString("ascii", offset + 4, offset + 8);
+        const dataStart = offset + 8;
+        const data = buffer.subarray(dataStart, dataStart + len);
+        if (type === "IHDR") {
+            width = data.readUInt32BE(0);
+            height = data.readUInt32BE(4);
+            const bitDepth = data[8];
+            const colorType = data[9];
+            const interlace = data[12];
+            if (bitDepth !== 8 || colorType !== 6 || interlace !== 0) {
+                throw new Error(`decodePNG: unsupported PNG (bitDepth=${bitDepth} colorType=${colorType} interlace=${interlace}); only 8-bit RGBA non-interlaced is supported`);
+            }
+        }
+        else if (type === "IDAT") {
+            idatParts.push(Buffer.from(data));
+        }
+        else if (type === "IEND") {
+            break;
+        }
+        offset = dataStart + len + 4; // skip data + CRC
+    }
+    const inflated = zlib.inflateSync(Buffer.concat(idatParts));
+    const bpp = 4;
+    const stride = width * bpp;
+    const out = new Uint8Array(width * height * bpp);
+    let prev = new Uint8Array(stride);
+    for (let y = 0; y < height; y++) {
+        const filterType = inflated[y * (stride + 1)];
+        const rowStart = y * (stride + 1) + 1;
+        const cur = new Uint8Array(stride);
+        for (let i = 0; i < stride; i++) {
+            const rawByte = inflated[rowStart + i];
+            const a = i >= bpp ? cur[i - bpp] : 0;
+            const b = prev[i];
+            const c = i >= bpp ? prev[i - bpp] : 0;
+            let value;
+            switch (filterType) {
+                case 0:
+                    value = rawByte;
+                    break;
+                case 1:
+                    value = rawByte + a;
+                    break;
+                case 2:
+                    value = rawByte + b;
+                    break;
+                case 3:
+                    value = rawByte + ((a + b) >> 1);
+                    break;
+                case 4:
+                    value = rawByte + paeth(a, b, c);
+                    break;
+                default: throw new Error(`decodePNG: unknown filter type ${filterType}`);
+            }
+            cur[i] = value & 0xff;
+        }
+        out.set(cur, y * stride);
+        prev = cur;
+    }
+    return { width, height, data: out };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coding-usage-bar",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "macOS menu bar usage monitor for Claude Code, Codex, GLM, DeepSeek, and MiniMax.",
   "author": "hanzhangzzz",
   "license": "MIT",