@frosted/array-reverse 1.0.0

package/README.md

@@ -0,0 +1,26 @@
+# @frosted/array-reverse
+Ponyfill for Array.prototype.reverse
+
+## Installation
+```bash
+npm install @frosted/array-reverse
+```
+
+## Usage
+```js
+const reverse = require("@frosted/array-reverse")
+
+console.log(reverse([1, 2, 3])) // [3, 2, 1]
+
+console.log(reverse("not array")) // Error: Expects an array
+```
+
+Shimming Array.prototype.reverse:
+```js
+require("@frosted/array-reverse/shim")
+
+console.log([1, 2, 3].reverse()) // [3, 2, 1]
+```
+
+## Tests
+Simply clone the repo and run npm test

package/index.d.ts

@@ -0,0 +1,3 @@
+declare function reverse<T>(arr: T[]): T[]
+
+export = reverse

package/index.js

@@ -0,0 +1,58 @@
+var isNotArray = require("@not-js/not")(require("@is-(unknown)/is-array"))
+var immediateError = require("immediate-error")
+var ish = require("es-logical-nullish-coalescing-operator")
+var one = require("@positive-numbers/one")
+var subtract = require("subtract")
+var isNotNegative = require("is-not-negative")
+var isEmptyArray = require("is-empty-array")
+var not = require("es-logical-not-operator")
+var and = require("es-logical-and-operator")
+var $RangeError = require("es-error-intrinsics/RangeError")
+var thro = require("bail")
+var isInstanceOf = require("@10xly/is-instance-of")
+
+// fallback for too much recursion
+function reverseAntiRecursion(array, offset) {
+  var result = require("lodash.stubarray")()
+  var currentOffset = ish(offset, subtract(array.length, one))
+  while (isNotNegative(currentOffset)) {
+    result.push(array[currentOffset])
+    currentOffset = subtract(currentOffset, one)
+  }
+  return result
+}
+
+function reverse(array, offset, bypass) {
+  if (isNotArray(array)) {
+    immediateError("Expects an array")
+  }
+
+  if (and(isEmptyArray(array), not(bypass))) {
+    var result = reverse(array, offset, not(bypass))
+    return and(not(result.shift()), result)
+  }
+
+  offset = ish(offset, subtract(array.length, one))
+
+  var result = [array[offset]]
+
+  if (isNotNegative(subtract(offset, one))) {
+    result = result.concat(reverse(array, subtract(offset, one)))
+  }
+
+  return result
+}
+
+function reverseWrapper(array) {
+  try {
+    return reverse(array)
+  } catch (error) {
+    if (isInstanceOf(error, $RangeError)) {
+      return reverseAntiRecursion(array)
+    } else {
+      thro( error )
+    }
+  }
+}
+
+module.exports = reverseWrapper

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@frosted/array-reverse",
+  "version": "1.0.0",
+  "description": "Reverse an array.",
+  "keywords": [
+    "10xly",
+    "mit",
+    "is-hundred",
+    "is-ten-thousand"
+  ],
+  "homepage": "https://github.com/frosted-javascript/array-reverse#readme",
+  "bugs": {
+    "url": "https://github.com/frosted-javascript/array-reverse/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/frosted-javascript/array-reverse.git"
+  },
+  "license": "MIT",
+  "author": "10x'ly Made",
+  "type": "commonjs",
+  "main": "index.js",
+  "scripts": {
+    "test": "mocha"
+  },
+  "dependencies": {
+    "@10xly/is-instance-of": "^1.0.0",
+    "@10xly/strict-equals": "^1.0.1",
+    "@is-(unknown)/is-array": "^1.0.2",
+    "@not-js/not": "^1.1.1",
+    "@positive-numbers/one": "^3.0.0",
+    "bail": "^1.0.5",
+    "define-properties": "^1.2.1",
+    "es-error-intrinsics": "^1.0.1",
+    "es-intrinsic-cache": "^1.0.4",
+    "es-logical-and-operator": "^1.0.0",
+    "es-logical-not-operator": "^1.0.0",
+    "es-logical-nullish-coalescing-operator": "^1.0.0",
+    "immediate-error": "^2.0.0",
+    "is-empty-array": "^1.1.0",
+    "is-not-negative": "^1.0.3",
+    "lodash.stubarray": "^4.13.0",
+    "subtract": "^0.0.3"
+  },
+  "devDependencies": {
+    "mocha": "^11.7.5"
+  }
+}

package/shim.js

@@ -0,0 +1,12 @@
+var define = require("define-properties")
+var polyfill = require(".")
+var $ArrayPrototype = require("es-intrinsic-cache")("Array.prototype")
+var isNotEqual = require("@not-js/not")("@10xly/strict-equals")
+
+define(
+  $ArrayPrototype,
+  { reverse: polyfill },
+  { reverse: function () { return isNotEqual($ArrayPrototype.reverse, polyfill) } }
+)
+
+module.exports = polyfill

package/test.js

@@ -0,0 +1,43 @@
+const assert = require("assert")
+const reverse = require(".")
+
+describe("reverse()", () => {
+  it("should reverse a standard array of numbers", () => {
+    const input = [1, 2, 3]
+    const expected = [3, 2, 1]
+    assert.deepStrictEqual(reverse(input), expected)
+  })
+
+  it("should work with an array of strings", () => {
+    const input = ["a", "b", "c", "d"]
+    const expected = ["d", "c", "b", "a"]
+    assert.deepStrictEqual(reverse(input), expected)
+  })
+
+  it("should return a single-element array unchanged", () => {
+    const input = [100]
+    assert.deepStrictEqual(reverse(input), input)
+  })
+
+  it("should throw an error when the input is not an array", () => {
+    assert.throws(() => {
+      reverse("not an array")
+    }, /Expects an array/)
+  })
+
+  it("should return empty array unchanged", () => {
+    assert.deepStrictEqual(reverse([]), [])
+  })
+
+  it("should handle a 15k length array", () => {
+    const size = 15000
+    const input = Array.from({ length: size }, (_, i) => i)
+
+    const expected = [...input].reverse()
+
+    const result = reverse(input)
+
+    assert.strictEqual(result.length, size)
+    assert.deepStrictEqual(result, expected)
+  })
+})