range-pie 2.1.0 → 2.3.0

package/README.md

@@ -29,6 +29,8 @@ A TypeScript/JavaScript library that brings Python's range functionality to Java
   - [includes()](#includes)
   - [indexOf()](#indexof)
   - [lastIndexOf()](#lastindexof)
+  - [pop()](#pop)
+  - [slice()](#slice)
   - [reverse()](#reverse)
 
 - [Advanced Usage](#advanced-usage)
@@ -43,6 +45,7 @@ A TypeScript/JavaScript library that brings Python's range functionality to Java
   - [Example Files](#example-files)
     - [Running the Examples](#running-the-examples)
     - [Available Examples](#available-examples)
+    - [Method-Specific Demonstrations](#method-specific-demonstrations)
 
 ## Installation
 
@@ -293,6 +296,35 @@ console.log(range.lastIndexOf(3));    // 2
 console.log(range.lastIndexOf(5));    // -1
 ```
 
+### pop()
+
+Similar to [**`Array.prototype.pop`**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop),
+this method removes the last value from the range, shortens the range and
+returns that value.
+
+```javascript
+const range = new PyRange(1, 5);  // [1, 2, 3, 4]
+console.log(range.pop());  // 4
+console.log([...range]);   // [1, 2, 3]
+```
+
+### slice()
+
+This method behaves similarly to [**`Array.prototype.slice`**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice).
+It returns a new PyRange instance containing elements from the specified indices.
+The original range is not modified.
+
+```javascript
+const range = new PyRange(0, 10);  // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+const sliced = range.slice(2, 5);
+console.log([...sliced]); // [2, 3, 4]
+console.log([...range]);  // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] (unchanged)
+
+// Negative indices are supported
+const lastThree = range.slice(-3);
+console.log([...lastThree]); // [7, 8, 9]
+```
+
 ### reverse()
 
 It works the same as [**`Array.prototype.reverse`**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse)
@@ -419,3 +451,14 @@ ts-node node_modules/range-pie/examples/typescript-usage.ts
 - **array-methods.js**: Demonstrates all array-like methods
 - **advanced-usage.js**: Covers advanced features like method chaining and proxy usage
 - **typescript-usage.ts**: Shows TypeScript-specific features and type safety
+
+#### Method-Specific Demonstrations
+
+For detailed demonstrations of individual methods, see the `examples/methods/` folder. Each method has its own comprehensive demo file with detailed explanations and use cases.
+
+```bash
+# Run all method demonstrations
+npm run example:methods
+```
+
+For instructions on running individual method demos and more details, see the [README in the examples/methods folder](examples/methods/README.md).

package/dist/py-range.d.ts

@@ -162,6 +162,31 @@ declare class PyRange implements Iterable<number> {
      * @returns {number} The index of the last occurrence of the value, or -1 if it is not present.
      */
     lastIndexOf(value: any): number;
+    /**
+     * Removes the last element from the range and returns it.
+     *
+     * This method behaves similarly to `Array.prototype.pop`. It decreases the
+     * `stop` value by the step size, shortens the range length by one, and returns
+     * the removed value. If the range is empty, `undefined` is returned and the
+     * range remains unchanged.
+     *
+     * @returns {number|undefined} The removed last value, or `undefined` if the
+     * range is empty.
+     */
+    pop(): number | undefined;
+    /**
+     * Returns a new PyRange instance containing elements from the specified indices.
+     *
+     * This method behaves similarly to `Array.prototype.slice`. It creates a new
+     * PyRange with elements from `begin` to `end` (exclusive) based on the given
+     * parameters. Negative indices are supported. The original range is not modified.
+     *
+     * @param {number} [begin=0] - Zero-based index at which to begin slicing.
+     * @param {number} [end=this.length] - Zero-based index at which to end slicing
+     *   (exclusive).
+     * @returns {PyRange} A new PyRange instance containing the sliced elements.
+     */
+    slice(begin?: number, end?: number): PyRange;
     /**
      * Reverses the order of the elements in this range, returning a new PyRange object.
      * @returns {PyRange} A new PyRange object with the elements in reverse order.

package/dist/py-range.js

@@ -303,6 +303,74 @@ class PyRange {
         }
         return -1;
     }
+    /**
+     * Removes the last element from the range and returns it.
+     *
+     * This method behaves similarly to `Array.prototype.pop`. It decreases the
+     * `stop` value by the step size, shortens the range length by one, and returns
+     * the removed value. If the range is empty, `undefined` is returned and the
+     * range remains unchanged.
+     *
+     * @returns {number|undefined} The removed last value, or `undefined` if the
+     * range is empty.
+     */
+    pop() {
+        if (this._length === 0) {
+            return undefined;
+        }
+        const lastValue = this.at(this._length - 1);
+        this._stop -= this._step;
+        this._length--;
+        return lastValue;
+    }
+    /**
+     * Returns a new PyRange instance containing elements from the specified indices.
+     *
+     * This method behaves similarly to `Array.prototype.slice`. It creates a new
+     * PyRange with elements from `begin` to `end` (exclusive) based on the given
+     * parameters. Negative indices are supported. The original range is not modified.
+     *
+     * @param {number} [begin=0] - Zero-based index at which to begin slicing.
+     * @param {number} [end=this.length] - Zero-based index at which to end slicing
+     *   (exclusive).
+     * @returns {PyRange} A new PyRange instance containing the sliced elements.
+     */
+    slice(begin = 0, end = this._length) {
+        if (typeof begin !== "number" || typeof end !== "number") {
+            throw new TypeError("Indices must be numbers");
+        }
+        if (!Number.isInteger(begin) || !Number.isInteger(end)) {
+            throw new TypeError("Indices must be integers");
+        }
+        const len = this._length;
+        let startIdx = begin;
+        let endIdx = end;
+        if (startIdx < 0) {
+            startIdx = Math.max(len + startIdx, 0);
+        }
+        else {
+            startIdx = Math.min(startIdx, len);
+        }
+        if (endIdx < 0) {
+            endIdx = Math.max(len + endIdx, 0);
+        }
+        else {
+            endIdx = Math.min(endIdx, len);
+        }
+        const origStart = this._start;
+        const step = this._step;
+        if (startIdx >= endIdx) {
+            // Return an empty range
+            const emptyStart = origStart + startIdx * step;
+            const result = new PyRange(emptyStart, emptyStart, step);
+            return result;
+        }
+        const newStart = origStart + startIdx * step;
+        const newStop = origStart + endIdx * step;
+        // Create a new PyRange instance with the calculated bounds
+        const result = new PyRange(newStart, newStop, step);
+        return result;
+    }
     /**
      * Reverses the order of the elements in this range, returning a new PyRange object.
      * @returns {PyRange} A new PyRange object with the elements in reverse order.

package/examples/array-methods.js

@@ -66,3 +66,13 @@ range.forEach((x) => {
 // 3 is divisible by 3
 // 6 is divisible by 3
 // 9 is divisible by 3
+
+// Pop: Remove the last value
+const popped = range.pop();
+console.log("pop():", popped); // 9
+console.log("After pop:", [...range]); // [1, 2, 3, 4, 5, 6, 7, 8]
+
+// Slice: Get a subset of the range (returns new instance)
+const sliced = range.slice(2, 5);
+console.log("slice(2, 5):", [...sliced]); // [3, 4, 5]
+console.log("Original after slice:", [...range]); // [1, 2, 3, 4, 5, 6, 7, 8] (unchanged)

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "range-pie",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "A TypeScript class that simulates Python's range function, combined with several useful JavaScript array methods.",
   "main": "dist/index.js",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
@@ -12,21 +13,30 @@
     }
   },
   "files": [
-    "dist",
-    "examples"
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "!dist/**/*.map",
+    "examples/*.js",
+    "examples/*.ts",
+    "!examples/methods"
   ],
   "scripts": {
     "build": "tsc",
     "build:prod": "tsc -p tsconfig.prod.json",
-    "prepublishOnly": "npm run build:prod",
+    "build:watch": "tsc --watch",
+    "prepublishOnly": "npm run build:prod && npm run test",
     "test": "jest",
+    "lint": "eslint . --ext .ts,.js",
+    "lint:fix": "eslint . --ext .ts,.js --fix",
+    "test:watch": "jest --watch",
     "clean": "rimraf dist",
     "format": "prettier --write \"src/**/*.{ts,js}\" \"test/**/*.{ts,js}\" \"examples/**/*.{ts,js}\" \"types/**/*.{ts,js,json}\" \"*.{js,json}\"",
-    "check-format": "prettier --check \"src/**/*.{ts,js}\" \"test/**/*.{ts,js}\" \"examples/**/*.{ts,js}\" \"types/**/*.{ts,js,json}\" \"*.{js,json}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,js}\" \"test/**/*.{ts,js}\" \"examples/**/*.{ts,js}\" \"types/**/*.{ts,js,json}\" \"*.{js,json}\"",
     "example:basic": "node examples/basic-usage.js",
     "example:array": "node examples/array-methods.js",
     "example:advanced": "node examples/advanced-usage.js",
-    "example:ts": "ts-node examples/typescript-usage.ts"
+    "example:ts": "ts-node examples/typescript-usage.ts",
+    "example:methods": "for file in examples/methods/*.ts; do echo \"\\n=== Running $file ===\"; ts-node \"$file\"; done"
   },
   "keywords": [
     "range",
@@ -46,12 +56,16 @@
     "url": "git+https://github.com/SkorpionG/range-pie.git"
   },
   "devDependencies": {
+    "@eslint/js": "^9.28.0",
     "@types/jest": "^29.5.0",
+    "eslint": "^9.28.0",
+    "globals": "^16.2.0",
     "jest": "^29.7.0",
     "prettier": "^3.5.3",
     "rimraf": "^5.0.0",
     "ts-jest": "^29.1.0",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4"
+    "typescript": "^5.0.4",
+    "typescript-eslint": "^8.33.1"
   }
 }