@lowdep/size-check 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rushabh Shah
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,139 @@
+# size-check
+
+![Zero dependencies](https://img.shields.io/badge/dependencies-0-brightgreen) ![Node](https://img.shields.io/badge/node-%3E%3D14-blue) ![License: MIT](https://img.shields.io/badge/license-MIT-green) ![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-lightgrey)
+
+
+Assert that your build artifacts haven't exceeded size limits. Gzip and Brotli aware. Zero dependencies.
+
+Like `size-limit` but with no dependencies. Like `bundlesize` but maintained.
+
+---
+
+## Install
+
+```bash
+npm install -g size-check
+```
+
+Or without installing:
+
+```bash
+npx size-check
+```
+
+---
+
+## Quick Start
+
+Add to your `package.json`:
+
+```json
+{
+  "size-check": [
+    { "path": "dist/*.js",  "maxSize": "100 kB" },
+    { "path": "dist/*.css", "maxSize": "20 kB", "gzip": true }
+  ]
+}
+```
+
+Then run:
+
+```bash
+size-check
+```
+
+---
+
+## Example Output
+
+```
+size-check  package.json
+
+  PATH                                      SIZE        LIMIT       %     STATUS
+  ────────────────────────────────────────  ──────────  ──────────  ────  ──────
+  dist/main.js                              87.4 kB     100 kB      87%   PASS
+  dist/vendor.js                            142.3 kB    100 kB      142%  FAIL
+  dist/styles.css                           14.2 kB gz  20 kB       71%   PASS
+
+  ───────────────────────────────────────────────────────────────────────────────
+  2 passed  1 failed
+```
+
+---
+
+## Config
+
+In `package.json`:
+
+```json
+{
+  "size-check": [
+    { "path": "dist/*.js",   "maxSize": "100 kB" },
+    { "path": "dist/*.css",  "maxSize": "20 kB",  "gzip": true },
+    { "path": "dist/**/*",   "maxSize": "500 kB", "brotli": true }
+  ]
+}
+```
+
+Or as `.sizecheckrc.json`:
+
+```json
+[
+  { "path": "dist/bundle.js", "maxSize": "100 kB" },
+  { "path": "dist/styles.css", "maxSize": "20 kB" }
+]
+```
+
+### Entry fields
+
+| Field | Type | Description |
+|---|---|---|
+| `path` | string | Glob pattern relative to config file |
+| `maxSize` | string | Size limit: `100 kB`, `1 MB`, `500 B` |
+| `gzip` | boolean | Check gzip-compressed size |
+| `brotli` | boolean | Check brotli-compressed size |
+
+---
+
+## CI Integration
+
+```yaml
+- name: Check bundle sizes
+  run: npx size-check
+```
+
+Exit code is `1` if any limit is exceeded.
+
+---
+
+## Options
+
+```bash
+size-check                  # Use .sizecheckrc.json or package.json
+size-check limits.json      # Use a specific config file
+size-check --gzip           # Force gzip checking for all entries
+size-check --brotli         # Force brotli checking for all entries
+size-check --dir dist/      # Set base directory
+```
+
+---
+
+## License
+
+MIT
+
+---
+
+## Keywords
+
+`bundle size` · `size-limit alternative` · `bundlesize alternative` · `ci size check` · `gzip size` · `brotli size` · `build size` · `asset size` · `zero dependencies` · `ci`
+
+---
+
+<div align="center">
+
+**Built to solve, shared to help — Rushabh Shah 🛠️✨**
+
+<sub>One of 40+ zero-dependency developer CLI tools — no <code>node_modules</code>, ever.</sub>
+
+</div>

package/bin/size-check.js

@@ -0,0 +1,329 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const zlib = require('zlib');
+
+const VERSION = '1.0.0';
+
+// ─── ANSI ─────────────────────────────────────────────────────────────────────
+const isTTY  = process.stdout.isTTY;
+const c      = (code, t) => isTTY ? `\x1b[${code}m${t}\x1b[0m` : t;
+const bold   = t => c('1',  t);
+const dim    = t => c('2',  t);
+const red    = t => c('31', t);
+const green  = t => c('32', t);
+const yellow = t => c('33', t);
+const cyan   = t => c('36', t);
+
+// ─── Size parsing / formatting ────────────────────────────────────────────────
+const SIZE_UNITS = {
+  b:  1,
+  kb: 1024,
+  mb: 1024 ** 2,
+  gb: 1024 ** 3,
+};
+
+function parseSize(str) {
+  const m = String(str).trim().match(/^([\d.]+)\s*(b|kb|kib|mb|mib|gb|gib)?$/i);
+  if (!m) throw new Error(`Invalid size: "${str}"`);
+  const num  = parseFloat(m[1]);
+  const unit = (m[2] || 'b').toLowerCase().replace('ib', '').replace('i', '');
+  return Math.round(num * (SIZE_UNITS[unit] || 1));
+}
+
+function formatSize(bytes) {
+  if (bytes < 1024)          return `${bytes} B`;
+  if (bytes < 1024 ** 2)     return `${(bytes / 1024).toFixed(1)} kB`;
+  if (bytes < 1024 ** 3)     return `${(bytes / 1024 ** 2).toFixed(2)} MB`;
+  return `${(bytes / 1024 ** 3).toFixed(2)} GB`;
+}
+
+function formatPercent(actual, limit) {
+  const pct = (actual / limit) * 100;
+  const s   = pct.toFixed(0) + '%';
+  if (pct > 100) return red(s);
+  if (pct > 85)  return yellow(s);
+  return green(s);
+}
+
+// ─── Glob-style file matching ─────────────────────────────────────────────────
+function globFiles(pattern, baseDir) {
+  const parts = pattern.split(/[/\\]/);
+  const results = [];
+
+  function walk(dir, depth) {
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); }
+    catch { return; }
+
+    const segment = parts[depth];
+    const isLast  = depth === parts.length - 1;
+
+    for (const e of entries) {
+      const full = path.join(dir, e.name);
+      if (segment === '**') {
+        // Match zero or more directories
+        if (e.isDirectory()) {
+          walk(full, depth);       // stay at ** level
+          walk(full, depth + 1);   // advance past **
+        } else if (isLast || matchSegment(e.name, parts[depth + 1])) {
+          if (isLast) results.push(full);
+          else if (matchSegment(e.name, parts[depth + 1])) results.push(full);
+        }
+      } else if (matchSegment(e.name, segment)) {
+        if (isLast && e.isFile()) {
+          results.push(full);
+        } else if (!isLast && e.isDirectory()) {
+          walk(full, depth + 1);
+        }
+      }
+    }
+  }
+
+  const isAbsolute = path.isAbsolute(pattern);
+  const absPattern = isAbsolute ? pattern : path.join(baseDir, pattern);
+  const absParts   = absPattern.split(/[/\\]/);
+
+  function walkAbs(dir, depth) {
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); }
+    catch { return; }
+
+    const segment = absParts[depth];
+    if (!segment) return;
+    const isLast = depth === absParts.length - 1;
+
+    for (const e of entries) {
+      const full = path.join(dir, e.name);
+      if (segment === '**') {
+        if (e.isDirectory()) { walkAbs(full, depth); walkAbs(full, depth + 1); }
+        else if (isLast)     { results.push(full); }
+        else if (matchSegment(e.name, absParts[depth + 1])) { results.push(full); }
+      } else if (matchSegment(e.name, segment)) {
+        if (isLast && e.isFile()) results.push(full);
+        else if (!isLast && e.isDirectory()) walkAbs(full, depth + 1);
+        else if (!isLast && e.isFile() && absParts.slice(depth + 1).every(p => p === '**')) results.push(full);
+      }
+    }
+  }
+
+  // Determine starting dir
+  let startDir = baseDir;
+  let startDepth = 0;
+  const ap = absPattern.split(/[/\\]/);
+  // Find first wildcard segment
+  for (let i = 0; i < ap.length; i++) {
+    if (ap[i].includes('*') || ap[i].includes('?')) { startDepth = i; break; }
+    if (i === ap.length - 1) {
+      // No wildcards — exact file
+      if (fs.existsSync(absPattern) && fs.statSync(absPattern).isFile()) results.push(absPattern);
+      return results;
+    }
+    startDir = ap.slice(0, i + 1).join(path.sep) || path.sep;
+    startDepth = i + 1;
+  }
+
+  walkAbs(startDir, startDepth);
+  return [...new Set(results)];
+}
+
+function matchSegment(name, pattern) {
+  if (!pattern || pattern === '**') return true;
+  const regStr = pattern
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*/g, '[^/\\\\]*')
+    .replace(/\?/g, '[^/\\\\]');
+  return new RegExp(`^${regStr}$`).test(name);
+}
+
+// ─── Compression size ─────────────────────────────────────────────────────────
+function gzipSize(buf) {
+  return zlib.gzipSync(buf, { level: 9 }).length;
+}
+
+function brotliSize(buf) {
+  if (!zlib.brotliCompressSync) return null; // Node <10.16
+  return zlib.brotliCompressSync(buf, { params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 11 } }).length;
+}
+
+// ─── Config loader ────────────────────────────────────────────────────────────
+function loadConfig(dir) {
+  // Try .sizecheckrc.json
+  const rcPath = path.join(dir, '.sizecheckrc.json');
+  if (fs.existsSync(rcPath)) {
+    return { limits: JSON.parse(fs.readFileSync(rcPath, 'utf8')), configFile: rcPath };
+  }
+
+  // Try package.json "size-check" key
+  const pkgPath = path.join(dir, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    if (pkg['size-check']) {
+      const cfg = pkg['size-check'];
+      return { limits: Array.isArray(cfg) ? cfg : cfg.limits, configFile: pkgPath };
+    }
+  }
+
+  return null;
+}
+
+// ─── CLI ──────────────────────────────────────────────────────────────────────
+const args        = process.argv.slice(2);
+const VALUE_FLAGS  = new Set(['--dir']);
+const positional = [];
+for (let i = 0; i < args.length; i++) {
+  if (args[i].startsWith('-')) { if (VALUE_FLAGS.has(args[i])) i++; }
+  else positional.push(args[i]);
+}
+
+function getFlag(f) {
+  const i = args.indexOf(f);
+  return i !== -1 ? args[i + 1] : null;
+}
+function hasFlag(f) { return args.includes(f); }
+
+if (hasFlag('--version') || hasFlag('-v')) {
+  console.log(`size-check v${VERSION}`); process.exit(0);
+}
+
+if (hasFlag('--help') || hasFlag('-h')) {
+  console.log(`
+${bold('size-check')} — Assert file/bundle sizes haven't exceeded limits, zero dependencies
+
+${bold('USAGE')}
+  size-check [config.json] [options]
+
+${bold('CONFIG')}
+  Reads limits from (in order):
+    .sizecheckrc.json
+    package.json "size-check" key
+
+${bold('CONFIG FORMAT')}
+  [
+    { "path": "dist/*.js",  "maxSize": "100 kB" },
+    { "path": "dist/*.css", "maxSize": "20 kB", "gzip": true },
+    { "path": "dist/**/*",  "maxSize": "500 kB", "brotli": true }
+  ]
+
+${bold('OPTIONS')}
+  --gzip          Check gzip-compressed size for all entries
+  --brotli        Check brotli-compressed size for all entries
+  --dir <path>    Base directory (default: .)
+  --version       Show version
+
+${bold('EXAMPLES')}
+  size-check                         # Use .sizecheckrc.json or package.json
+  size-check limits.json             # Use a specific config file
+  size-check --gzip                  # Override: check gzip sizes
+`);
+  process.exit(0);
+}
+
+const baseDir     = path.resolve(getFlag('--dir') || '.');
+const forceGzip   = hasFlag('--gzip');
+const forceBrotli = hasFlag('--brotli');
+
+// Load config
+let limits;
+let configFile;
+
+if (positional[0]) {
+  const cfgPath = path.resolve(positional[0]);
+  if (!fs.existsSync(cfgPath)) {
+    console.error(red(`\nConfig file not found: ${cfgPath}\n`)); process.exit(1);
+  }
+  const raw = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+  limits     = Array.isArray(raw) ? raw : raw.limits;
+  configFile = cfgPath;
+} else {
+  const cfg = loadConfig(baseDir);
+  if (!cfg) {
+    console.error(red(`\nNo size-check config found.`));
+    console.log(dim(`  Create .sizecheckrc.json or add "size-check" to package.json\n`));
+    process.exit(1);
+  }
+  limits     = cfg.limits;
+  configFile = cfg.configFile;
+}
+
+if (!Array.isArray(limits) || !limits.length) {
+  console.error(red('\nNo limits defined in config.\n')); process.exit(1);
+}
+
+// ─── Run checks ───────────────────────────────────────────────────────────────
+// Collect all rows first, then render with proper column widths
+
+const rows = [];
+let pass = 0, fail = 0;
+
+for (const entry of limits) {
+  let maxBytes;
+  try { maxBytes = parseSize(entry.maxSize || entry.max || entry.limit || '0'); }
+  catch (e) { console.error(red(`  Invalid maxSize "${entry.maxSize}": ${e.message}`)); fail++; continue; }
+
+  const useGzip   = forceGzip   || entry.gzip;
+  const useBrotli = forceBrotli || entry.brotli;
+  const files     = globFiles(entry.path, baseDir);
+
+  if (files.length === 0) {
+    rows.push({ pathStr: entry.path, sizeStr: '(no files)', limitStr: formatSize(maxBytes), pctStr: '—', ok: null });
+    continue;
+  }
+
+  for (const filePath of files) {
+    const buf = fs.readFileSync(filePath);
+    let size, suffix;
+
+    if (useBrotli) {
+      size = brotliSize(buf); suffix = ' br';
+    } else if (useGzip) {
+      size = gzipSize(buf);   suffix = ' gz';
+    } else {
+      size = buf.length;      suffix = '';
+    }
+
+    const ok       = size <= maxBytes;
+    const pct      = ((size / maxBytes) * 100).toFixed(0) + '%';
+    const rel      = path.relative(baseDir, filePath);
+
+    rows.push({ pathStr: rel, sizeStr: formatSize(size) + suffix, limitStr: formatSize(maxBytes), pctStr: pct, ok });
+    if (ok) pass++; else fail++;
+  }
+}
+
+// Compute column widths from plain (un-colored) strings
+const W = {
+  path:  Math.max(4, ...rows.map(r => r.pathStr.length)),
+  size:  Math.max(4, ...rows.map(r => r.sizeStr.length)),
+  limit: Math.max(5, ...rows.map(r => r.limitStr.length)),
+  pct:   Math.max(1, ...rows.map(r => r.pctStr.length)),
+};
+
+console.log(`\n${bold('size-check')}  ${dim(path.relative(process.cwd(), configFile))}\n`);
+console.log(`  ${'PATH'.padEnd(W.path)}  ${'SIZE'.padEnd(W.size)}  ${'LIMIT'.padEnd(W.limit)}  ${'%'.padStart(W.pct)}  STATUS`);
+console.log(`  ${'─'.repeat(W.path)}  ${'─'.repeat(W.size)}  ${'─'.repeat(W.limit)}  ${'─'.repeat(W.pct)}  ──────`);
+
+for (const r of rows) {
+  if (r.ok === null) {
+    console.log(`  ${dim(r.pathStr.padEnd(W.path))}  ${yellow(r.sizeStr.padEnd(W.size))}  ${dim(r.limitStr.padEnd(W.limit))}  ${'—'.padStart(W.pct)}  ${yellow('WARN')}`);
+  } else {
+    const pathFmt  = r.ok ? r.pathStr.padEnd(W.path)        : bold(r.pathStr.padEnd(W.path));
+    const sizeFmt  = r.ok ? r.sizeStr.padEnd(W.size)        : red(r.sizeStr.padEnd(W.size));
+    const limitFmt = dim(r.limitStr.padEnd(W.limit));
+    const pctFmt   = r.pctStr.padStart(W.pct);
+    const colorPct = parseInt(r.pctStr) > 100 ? red(pctFmt) : parseInt(r.pctStr) > 85 ? yellow(pctFmt) : green(pctFmt);
+    const status   = r.ok ? green('PASS') : red('FAIL');
+    console.log(`  ${pathFmt}  ${sizeFmt}  ${limitFmt}  ${colorPct}  ${status}`);
+  }
+}
+
+console.log(`\n  ${'─'.repeat(W.path + W.size + W.limit + W.pct + 20)}`);
+if (fail === 0) {
+  console.log(green(`  All ${pass} check(s) passed\n`));
+} else {
+  console.log(`  ${green(`${pass} passed`)}  ${red(`${fail} failed`)}\n`);
+}
+
+process.exit(fail > 0 ? 1 : 0);

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@lowdep/size-check",
+  "version": "1.0.0",
+  "description": "Assert build artifact sizes haven't exceeded limits — gzip/brotli aware CI tool, zero dependencies",
+  "bin": {
+    "size-check": "bin/size-check.js"
+  },
+  "keywords": [
+    "bundle-size",
+    "size-limit",
+    "ci",
+    "build",
+    "performance",
+    "cli",
+    "zero-dependencies",
+    "bundle size",
+    "size-limit alternative",
+    "bundlesize alternative",
+    "ci size check",
+    "gzip size",
+    "brotli size",
+    "build size",
+    "asset size",
+    "zero dependencies"
+  ],
+  "author": "Rushabh Shah",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14"
+  },
+  "files": [
+    "bin/"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rushabh5000/size-check.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Rushabh5000/size-check/issues"
+  },
+  "homepage": "https://github.com/Rushabh5000/size-check#readme",
+  "publishConfig": {
+    "access": "public"
+  }
+}