raid-capacity 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ricco020
+
+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,40 @@
+# raid-capacity
+
+Compute the **usable capacity**, **fault tolerance** and **efficiency** of a RAID
+array for the common levels (0, 1, 5, 6, 10). Pure arithmetic, zero dependencies.
+
+```js
+const raidCapacity = require('raid-capacity');
+
+raidCapacity({ disks: 4, diskSizeGB: 4000, level: 5 });
+// { level:'5', disks:4, diskSizeGB:4000, usableGB:12000, rawGB:16000,
+//   faultToleranceDisks:1, efficiencyPercent:75 }
+
+raidCapacity({ disks: 4, diskSizeGB: 4000, level: 10 }).usableGB; // 8000
+```
+
+Accepts `level` as a number (`5`) or string (`"raid5"`). Throws on invalid disk
+counts (RAID 5 needs 3+, RAID 6 needs 4+, RAID 10 needs an even count of 4+).
+
+## Levels
+
+| Level | Usable | Fault tolerance | Min disks |
+|------|--------|-----------------|-----------|
+| 0  | n x size        | 0 disks | 2 |
+| 1  | size (mirror)   | n-1 disks | 2 |
+| 5  | (n-1) x size    | 1 disk | 3 |
+| 6  | (n-2) x size    | 2 disks | 4 |
+| 10 | (n/2) x size    | 1 disk (guaranteed) | 4, even |
+
+**Note:** capacity assumes identical disks and is a theoretical figure; real
+controllers and filesystems round down a little, and RAID is not a backup.
+
+## Notes
+
+Maintained by the team behind [Save My Disk](https://www.save-my-disk.com), a data
+recovery and backup resource. For plain-English guides on RAID, backups and data
+recovery, see [save-my-disk.com](https://www.save-my-disk.com).
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,54 @@
+'use strict';
+
+/**
+ * raid-capacity
+ * Compute the usable capacity, fault tolerance and efficiency of a RAID array
+ * for the common levels (0, 1, 5, 6, 10). Pure arithmetic, no dependencies.
+ * Capacity assumes identical disks; real controllers round down slightly.
+ */
+
+var LEVELS = {
+  '0':  { min: 2, usable: function (n, s) { return n * s; },        tol: function () { return 0; } },
+  '1':  { min: 2, usable: function (n, s) { return s; },            tol: function (n) { return n - 1; } },
+  '5':  { min: 3, usable: function (n, s) { return (n - 1) * s; },  tol: function () { return 1; } },
+  '6':  { min: 4, usable: function (n, s) { return (n - 2) * s; },  tol: function () { return 2; } },
+  '10': { min: 4, usable: function (n, s) { return (n / 2) * s; },  tol: function () { return 1; }, evenOnly: true }
+};
+
+function normLevel(level) {
+  var l = String(level).toLowerCase().replace(/^raid[\s-]?/, '');
+  return LEVELS[l] ? l : null;
+}
+
+/**
+ * @param {object} opts
+ * @param {number} opts.disks number of identical disks
+ * @param {number} opts.diskSizeGB size of each disk in GB
+ * @param {(number|string)} opts.level RAID level: 0,1,5,6,10 (or "raid5")
+ * @returns {{level:string, disks:number, diskSizeGB:number, usableGB:number, rawGB:number, faultToleranceDisks:number, efficiencyPercent:number}}
+ */
+function raidCapacity(opts) {
+  if (!opts || typeof opts !== 'object') { throw new TypeError('expected an options object'); }
+  var n = opts.disks, s = opts.diskSizeGB;
+  if (!Number.isFinite(n) || n < 1 || n % 1 !== 0) { throw new RangeError('disks must be a positive integer'); }
+  if (!Number.isFinite(s) || s <= 0) { throw new RangeError('diskSizeGB must be a positive number'); }
+  var key = normLevel(opts.level);
+  if (!key) { throw new RangeError('unsupported RAID level (use 0, 1, 5, 6 or 10)'); }
+  var spec = LEVELS[key];
+  if (n < spec.min) { throw new RangeError('RAID ' + key + ' needs at least ' + spec.min + ' disks'); }
+  if (spec.evenOnly && n % 2 !== 0) { throw new RangeError('RAID ' + key + ' needs an even number of disks'); }
+  var usable = spec.usable(n, s);
+  var raw = n * s;
+  return {
+    level: key,
+    disks: n,
+    diskSizeGB: s,
+    usableGB: Math.round(usable * 100) / 100,
+    rawGB: raw,
+    faultToleranceDisks: spec.tol(n),
+    efficiencyPercent: Math.round((usable / raw) * 1000) / 10
+  };
+}
+
+module.exports = raidCapacity;
+module.exports.raidCapacity = raidCapacity;

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "raid-capacity",
+  "version": "1.0.0",
+  "description": "Compute usable capacity, fault tolerance and efficiency for RAID 0/1/5/6/10 arrays. Pure arithmetic, zero dependencies.",
+  "main": "index.js",
+  "type": "commonjs",
+  "scripts": { "test": "node test.js" },
+  "keywords": ["raid", "storage", "capacity", "raid5", "raid6", "raid10", "fault-tolerance", "nas"],
+  "homepage": "https://www.save-my-disk.com",
+  "author": "ricco020",
+  "license": "MIT",
+  "engines": { "node": ">=12" },
+  "files": ["index.js", "README.md", "LICENSE"]
+}