@arvarus/perlin-noise 0.1.1

package/LICENSE

@@ -0,0 +1,18 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2024 @arvarus/perlin-noise contributors
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+

package/README.md

@@ -0,0 +1,132 @@
+# @arvarus/perlin-noise
+
+Perlin noise implementation in TypeScript.
+
+## Installation
+
+```bash
+npm install @arvarus/perlin-noise
+```
+
+## Usage
+
+### Basic Example
+
+```typescript
+import { PerlinNoise } from '@arvarus/perlin-noise';
+
+// Create a Perlin noise instance
+const noise = new PerlinNoise({
+  seed: 42,           // Optional: seed for reproducible results
+  gridSize: [64, 64]  // Optional: grid size for each dimension (default: [64, 64, 64])
+});
+
+// Generate noise value at coordinates
+const value = noise.noise([10.5, 20.3]);
+console.log(value); // Output: a value approximately in range [-1, 1]
+```
+
+### 1D Noise
+
+```typescript
+const noise = new PerlinNoise({ 
+  seed: 123, 
+  gridSize: [100]  // 1D grid
+});
+
+// Generate 1D noise along a line
+for (let x = 0; x < 10; x += 0.1) {
+  const value = noise.noise([x]);
+  console.log(`x: ${x}, noise: ${value}`);
+}
+```
+
+### Using a Fixed Seed for Reproducible Results
+
+```typescript
+// Same seed produces same noise pattern
+const noise1 = new PerlinNoise({ seed: 42, gridSize: [64, 64] });
+const noise2 = new PerlinNoise({ seed: 42, gridSize: [64, 64] });
+
+const value1 = noise1.noise([5.0, 5.0]);
+const value2 = noise2.noise([5.0, 5.0]);
+
+console.log(value1 === value2); // true - same seed produces same result
+```
+
+## API Reference
+
+### `PerlinNoise`
+
+Main class for generating Perlin noise values. Supports 1 to 10 dimensions.
+
+#### Constructor
+
+```typescript
+new PerlinNoise(options?: PerlinNoiseOptions)
+```
+
+Creates a new PerlinNoise instance.
+
+**Parameters:**
+- `options` (optional): Configuration object
+  - `seed?: number` - Seed for random number generation. If not provided, a random seed is used.
+  - `gridSize?: number[]` - Grid size for each dimension. Default: `[64, 64, 64]`. The grid wraps around, so smaller values can be used for repeating patterns. Must be an array of length 1 to 10.
+
+**Example:**
+```typescript
+// Default 3D noise
+const noise1 = new PerlinNoise();
+
+// 2D noise with fixed seed
+const noise2 = new PerlinNoise({ seed: 42, gridSize: [64, 64] });
+
+// 1D noise
+const noise3 = new PerlinNoise({ gridSize: [100] });
+```
+
+#### Methods
+
+##### `noise(coordinates: number[]): number`
+
+Generates a noise value at the given coordinates.
+
+**Parameters:**
+- `coordinates: number[]` - Array of coordinates. The length must match the grid dimension specified in the constructor.
+
+**Returns:**
+- `number` - Noise value approximately in the range `[-1, 1]`
+
+**Example:**
+```typescript
+const noise = new PerlinNoise({ gridSize: [64, 64] });
+
+// 2D coordinates for 2D grid
+const value = noise.noise([10.5, 20.3]);
+
+// Coordinates wrap around the grid bounds
+const wrapped = noise.noise([100.0, 200.0]); // Wraps to [36, 8] for 64x64 grid
+```
+
+**Throws:**
+- `Error` - If the coordinates array length doesn't match the grid dimension
+
+### `PerlinNoiseOptions`
+
+Configuration interface for PerlinNoise constructor.
+
+```typescript
+interface PerlinNoiseOptions {
+  seed?: number;
+  gridSize?: number[];
+}
+```
+
+**Properties:**
+- `seed?: number` - Seed for random number generation. Same seed produces the same noise pattern.
+- `gridSize?: number[]` - Grid size for each dimension. Default: `[64, 64, 64]`. Must be an array of length 1 to 10. The grid wraps around, allowing for seamless repeating patterns.
+
+## License
+
+GPL-3.0
+

package/dist/__tests__/grid.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/grid.test.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const grid_1 = require("../grid");
+describe('generateGradientGrid', () => {
+    describe('1D grid', () => {
+        it('should generate correct number of grid points', () => {
+            const grid = (0, grid_1.generateGradientGrid)(1, [5], 123);
+            expect(grid.size).toBe(6); // size + 1
+        });
+        it('should generate scalars between -1 and 1', () => {
+            const grid = (0, grid_1.generateGradientGrid)(1, [10], 456);
+            for (const gradient of grid.values()) {
+                expect(typeof gradient).toBe('number');
+                const scalar = gradient;
+                expect(scalar).toBeGreaterThanOrEqual(-1);
+                expect(scalar).toBeLessThanOrEqual(1);
+            }
+        });
+        it('should generate same grid with same seed', () => {
+            const grid1 = (0, grid_1.generateGradientGrid)(1, [5], 789);
+            const grid2 = (0, grid_1.generateGradientGrid)(1, [5], 789);
+            expect(grid1.size).toBe(grid2.size);
+            for (const [key, value] of grid1.entries()) {
+                expect(grid2.get(key)).toBe(value);
+            }
+        });
+        it('should generate different grid with different seed', () => {
+            const grid1 = (0, grid_1.generateGradientGrid)(1, [5], 100);
+            const grid2 = (0, grid_1.generateGradientGrid)(1, [5], 200);
+            // At least some values should be different
+            let hasDifference = false;
+            for (const [key, value] of grid1.entries()) {
+                if (grid2.get(key) !== value) {
+                    hasDifference = true;
+                    break;
+                }
+            }
+            expect(hasDifference).toBe(true);
+        });
+        it('should have correct keys for 1D grid', () => {
+            const grid = (0, grid_1.generateGradientGrid)(1, [3], 123);
+            expect(grid.has('0')).toBe(true);
+            expect(grid.has('1')).toBe(true);
+            expect(grid.has('2')).toBe(true);
+            expect(grid.has('3')).toBe(true);
+            expect(grid.has('4')).toBe(false);
+        });
+    });
+    describe('2D grid', () => {
+        it('should generate correct number of grid points', () => {
+            const grid = (0, grid_1.generateGradientGrid)(2, [3, 3], 123);
+            expect(grid.size).toBe(16); // (3 + 1) * (3 + 1) = 16
+        });
+        it('should generate unit-length 2D vectors', () => {
+            const grid = (0, grid_1.generateGradientGrid)(2, [5, 5], 456);
+            for (const gradient of grid.values()) {
+                expect(Array.isArray(gradient)).toBe(true);
+                const vector = gradient;
+                expect(vector.length).toBe(2);
+                // Check unit length (within floating point precision)
+                const magnitude = Math.sqrt(vector[0] * vector[0] + vector[1] * vector[1]);
+                expect(magnitude).toBeCloseTo(1, 10);
+            }
+        });
+        it('should generate same grid with same seed', () => {
+            const grid1 = (0, grid_1.generateGradientGrid)(2, [3, 3], 789);
+            const grid2 = (0, grid_1.generateGradientGrid)(2, [3, 3], 789);
+            expect(grid1.size).toBe(grid2.size);
+            for (const [key, value] of grid1.entries()) {
+                const v1 = value;
+                const v2 = grid2.get(key);
+                expect(v2).toBeDefined();
+                expect(v1[0]).toBeCloseTo(v2[0], 10);
+                expect(v1[1]).toBeCloseTo(v2[1], 10);
+            }
+        });
+        it('should have correct keys for 2D grid', () => {
+            const grid = (0, grid_1.generateGradientGrid)(2, [2, 2], 123);
+            expect(grid.has('0,0')).toBe(true);
+            expect(grid.has('0,1')).toBe(true);
+            expect(grid.has('1,0')).toBe(true);
+            expect(grid.has('2,2')).toBe(true);
+            expect(grid.has('3,3')).toBe(false); // size is 2, so max is 2
+        });
+        it('should support different sizes per dimension', () => {
+            const grid = (0, grid_1.generateGradientGrid)(2, [2, 3], 123);
+            // First dimension: 2 + 1 = 3 points (0, 1, 2)
+            // Second dimension: 3 + 1 = 4 points (0, 1, 2, 3)
+            // Total: 3 * 4 = 12 points
+            expect(grid.size).toBe(12);
+            expect(grid.has('0,0')).toBe(true);
+            expect(grid.has('2,3')).toBe(true);
+            expect(grid.has('3,3')).toBe(false); // First dimension max is 2
+            expect(grid.has('2,4')).toBe(false); // Second dimension max is 3
+        });
+    });
+    describe('3D grid', () => {
+        it('should generate correct number of grid points', () => {
+            const grid = (0, grid_1.generateGradientGrid)(3, [2, 2, 2], 123);
+            expect(grid.size).toBe(27); // (2 + 1) ^ 3 = 27
+        });
+        it('should generate unit-length 3D vectors', () => {
+            const grid = (0, grid_1.generateGradientGrid)(3, [3, 3, 3], 456);
+            for (const gradient of grid.values()) {
+                expect(Array.isArray(gradient)).toBe(true);
+                const vector = gradient;
+                expect(vector.length).toBe(3);
+                // Check unit length
+                const magnitude = Math.sqrt(vector[0] * vector[0] +
+                    vector[1] * vector[1] +
+                    vector[2] * vector[2]);
+                expect(magnitude).toBeCloseTo(1, 10);
+            }
+        });
+        it('should generate same grid with same seed', () => {
+            const grid1 = (0, grid_1.generateGradientGrid)(3, [2, 2, 2], 789);
+            const grid2 = (0, grid_1.generateGradientGrid)(3, [2, 2, 2], 789);
+            expect(grid1.size).toBe(grid2.size);
+            for (const [key, value] of grid1.entries()) {
+                const v1 = value;
+                const v2 = grid2.get(key);
+                expect(v2).toBeDefined();
+                expect(v1[0]).toBeCloseTo(v2[0], 10);
+                expect(v1[1]).toBeCloseTo(v2[1], 10);
+                expect(v1[2]).toBeCloseTo(v2[2], 10);
+            }
+        });
+        it('should have correct keys for 3D grid', () => {
+            const grid = (0, grid_1.generateGradientGrid)(3, [1, 1, 1], 123);
+            expect(grid.has('0,0,0')).toBe(true);
+            expect(grid.has('1,1,1')).toBe(true);
+            expect(grid.has('2,2,2')).toBe(false); // size is 1, so max is 1
+        });
+    });
+    describe('4D grid', () => {
+        it('should generate correct number of grid points', () => {
+            const grid = (0, grid_1.generateGradientGrid)(4, [2, 2, 2, 2], 123);
+            expect(grid.size).toBe(81); // (2 + 1) ^ 4 = 81
+        });
+        it('should generate unit-length 4D vectors', () => {
+            const grid = (0, grid_1.generateGradientGrid)(4, [2, 2, 2, 2], 456);
+            for (const gradient of grid.values()) {
+                expect(Array.isArray(gradient)).toBe(true);
+                const vector = gradient;
+                expect(vector.length).toBe(4);
+                // Check unit length
+                const magnitude = Math.sqrt(vector[0] * vector[0] +
+                    vector[1] * vector[1] +
+                    vector[2] * vector[2] +
+                    vector[3] * vector[3]);
+                expect(magnitude).toBeCloseTo(1, 10);
+            }
+        });
+        it('should generate same grid with same seed', () => {
+            const grid1 = (0, grid_1.generateGradientGrid)(4, [1, 1, 1, 1], 789);
+            const grid2 = (0, grid_1.generateGradientGrid)(4, [1, 1, 1, 1], 789);
+            expect(grid1.size).toBe(grid2.size);
+            for (const [key, value] of grid1.entries()) {
+                const v1 = value;
+                const v2 = grid2.get(key);
+                expect(v2).toBeDefined();
+                expect(v1[0]).toBeCloseTo(v2[0], 10);
+                expect(v1[1]).toBeCloseTo(v2[1], 10);
+                expect(v1[2]).toBeCloseTo(v2[2], 10);
+                expect(v1[3]).toBeCloseTo(v2[3], 10);
+            }
+        });
+        it('should have correct keys for 4D grid', () => {
+            const grid = (0, grid_1.generateGradientGrid)(4, [1, 1, 1, 1], 123);
+            expect(grid.has('0,0,0,0')).toBe(true);
+            expect(grid.has('1,1,1,1')).toBe(true);
+            expect(grid.has('2,2,2,2')).toBe(false); // size is 1, so max is 1
+        });
+    });
+    describe('higher dimensions', () => {
+        it('should support 5D grids', () => {
+            const grid = (0, grid_1.generateGradientGrid)(5, [1, 1, 1, 1, 1], 123);
+            expect(grid.size).toBe(32); // (1 + 1) ^ 5 = 32
+            expect(grid.has('0,0,0,0,0')).toBe(true);
+            expect(grid.has('1,1,1,1,1')).toBe(true);
+            expect(grid.has('2,2,2,2,2')).toBe(false);
+            // Check that gradients are arrays of length 5
+            for (const gradient of grid.values()) {
+                expect(Array.isArray(gradient)).toBe(true);
+                const vector = gradient;
+                expect(vector.length).toBe(5);
+                // Check unit length
+                const magnitude = Math.sqrt(vector.reduce((sum, val) => sum + val * val, 0));
+                expect(magnitude).toBeCloseTo(1, 10);
+            }
+        });
+        it('should support 6D grids', () => {
+            const grid = (0, grid_1.generateGradientGrid)(6, [1, 1, 1, 1, 1, 1], 123);
+            expect(grid.size).toBe(64); // (1 + 1) ^ 6 = 64
+            expect(grid.has('0,0,0,0,0,0')).toBe(true);
+            expect(grid.has('1,1,1,1,1,1')).toBe(true);
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle size 0', () => {
+            const grid = (0, grid_1.generateGradientGrid)(1, [0], 123);
+            expect(grid.size).toBe(1); // 0 + 1 = 1
+            expect(grid.has('0')).toBe(true);
+        });
+        it('should handle size 0 for 2D', () => {
+            const grid = (0, grid_1.generateGradientGrid)(2, [0, 0], 123);
+            expect(grid.size).toBe(1); // (0 + 1) ^ 2 = 1
+            expect(grid.has('0,0')).toBe(true);
+        });
+        it('should use different default seeds when seed not provided', () => {
+            const grid1 = (0, grid_1.generateGradientGrid)(1, [5]);
+            const grid2 = (0, grid_1.generateGradientGrid)(1, [5]);
+            // They might be the same by chance, but very unlikely
+            // We'll just check that the function doesn't crash
+            expect(grid1.size).toBe(6);
+            expect(grid2.size).toBe(6);
+        });
+        it('should throw error when size array length does not match dimension', () => {
+            expect(() => (0, grid_1.generateGradientGrid)(2, [3], 123)).toThrow();
+            expect(() => (0, grid_1.generateGradientGrid)(2, [3, 4, 5], 123)).toThrow();
+            expect(() => (0, grid_1.generateGradientGrid)(3, [2, 2], 123)).toThrow();
+        });
+        it('should throw error when dimension is not a positive integer', () => {
+            expect(() => (0, grid_1.generateGradientGrid)(0, [], 123)).toThrow();
+            expect(() => (0, grid_1.generateGradientGrid)(-1, [-1], 123)).toThrow();
+            expect(() => (0, grid_1.generateGradientGrid)(1.5, [1], 123)).toThrow();
+            expect(() => (0, grid_1.generateGradientGrid)(2.0, [1, 1], 123)).not.toThrow(); // 2.0 is valid
+        });
+    });
+});
+describe('getGradientAt', () => {
+    it('should retrieve gradient from 1D grid', () => {
+        const grid = (0, grid_1.generateGradientGrid)(1, [5], 123);
+        const gradient = (0, grid_1.getGradientAt)(grid, [2]);
+        expect(gradient).toBeDefined();
+        expect(typeof gradient).toBe('number');
+        expect(gradient).toBe(grid.get('2'));
+    });
+    it('should retrieve gradient from 2D grid', () => {
+        const grid = (0, grid_1.generateGradientGrid)(2, [3, 3], 123);
+        const gradient = (0, grid_1.getGradientAt)(grid, [1, 2]);
+        expect(gradient).toBeDefined();
+        expect(Array.isArray(gradient)).toBe(true);
+        expect(gradient).toEqual(grid.get('1,2'));
+    });
+    it('should retrieve gradient from 3D grid', () => {
+        const grid = (0, grid_1.generateGradientGrid)(3, [2, 2, 2], 123);
+        const gradient = (0, grid_1.getGradientAt)(grid, [1, 0, 2]);
+        expect(gradient).toBeDefined();
+        expect(Array.isArray(gradient)).toBe(true);
+        expect(gradient).toEqual(grid.get('1,0,2'));
+    });
+    it('should retrieve gradient from 4D grid', () => {
+        const grid = (0, grid_1.generateGradientGrid)(4, [1, 1, 1, 1], 123);
+        const gradient = (0, grid_1.getGradientAt)(grid, [1, 1, 0, 1]);
+        expect(gradient).toBeDefined();
+        expect(Array.isArray(gradient)).toBe(true);
+        expect(gradient).toEqual(grid.get('1,1,0,1'));
+    });
+    it('should return undefined for non-existent coordinates', () => {
+        const grid = (0, grid_1.generateGradientGrid)(2, [3, 3], 123);
+        const gradient = (0, grid_1.getGradientAt)(grid, [10, 10]);
+        expect(gradient).toBeUndefined();
+    });
+    it('should return undefined for empty grid', () => {
+        const emptyGrid = new Map();
+        const gradient = (0, grid_1.getGradientAt)(emptyGrid, [0, 0]);
+        expect(gradient).toBeUndefined();
+    });
+});

package/dist/__tests__/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/index.test.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+describe('PerlinNoise', () => {
+    describe('constructor', () => {
+        it('should create instance with default options', () => {
+            const noise = new index_1.PerlinNoise();
+            expect(noise).toBeInstanceOf(index_1.PerlinNoise);
+        });
+        it('should create instance with options object', () => {
+            const options = { seed: 456, gridSize: [10, 10, 10] };
+            const noise = new index_1.PerlinNoise(options);
+            expect(noise).toBeInstanceOf(index_1.PerlinNoise);
+        });
+        it('should use provided seed', () => {
+            const noise1 = new index_1.PerlinNoise({ seed: 789, gridSize: [10, 10, 10] });
+            const noise2 = new index_1.PerlinNoise({ seed: 789, gridSize: [10, 10, 10] });
+            // Same seed should produce same results
+            expect(noise1.noise([1.0, 1.0, 1.0])).toBeCloseTo(noise2.noise([1.0, 1.0, 1.0]), 10);
+        });
+        it('should use default grid size when not provided', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123 });
+            // Should work with 3D coordinates (default dimension)
+            const value = noise.noise([1.0, 1.0, 1.0]);
+            expect(typeof value).toBe('number');
+        });
+        it('should throw error for invalid grid size length', () => {
+            expect(() => new index_1.PerlinNoise({ gridSize: [] })).toThrow();
+            expect(() => new index_1.PerlinNoise({ gridSize: Array(11).fill(10) })).toThrow();
+        });
+    });
+    describe('1D noise', () => {
+        it('should generate noise value for 1D coordinates', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10] });
+            const value = noise.noise([1.5]);
+            expect(typeof value).toBe('number');
+            expect(value).toBeGreaterThanOrEqual(-2);
+            expect(value).toBeLessThanOrEqual(2);
+        });
+        it('should produce consistent results for same point', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10] });
+            const value1 = noise.noise([2.3]);
+            const value2 = noise.noise([2.3]);
+            expect(value1).toBeCloseTo(value2, 10);
+        });
+        it('should produce different results for different points', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10] });
+            const value1 = noise.noise([1.0]);
+            const value2 = noise.noise([5.0]);
+            // They might be the same by chance, but very unlikely
+            expect(typeof value1).toBe('number');
+            expect(typeof value2).toBe('number');
+        });
+        it('should handle negative coordinates', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10] });
+            const value = noise.noise([-1.5]);
+            expect(typeof value).toBe('number');
+        });
+        it('should handle large coordinates (wrapping)', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10] });
+            const value1 = noise.noise([1.5]);
+            const value2 = noise.noise([11.5]); // Should wrap to 1.5
+            expect(value1).toBeCloseTo(value2, 10);
+        });
+        it('should handle coordinates at grid boundaries', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10] });
+            const value = noise.noise([10.0]);
+            expect(typeof value).toBe('number');
+        });
+    });
+    describe('2D noise', () => {
+        it('should generate noise value for 2D coordinates', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10] });
+            const value = noise.noise([1.5, 2.3]);
+            expect(typeof value).toBe('number');
+            expect(value).toBeGreaterThanOrEqual(-2);
+            expect(value).toBeLessThanOrEqual(2);
+        });
+        it('should produce consistent results for same point', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10] });
+            const value1 = noise.noise([2.3, 4.7]);
+            const value2 = noise.noise([2.3, 4.7]);
+            expect(value1).toBeCloseTo(value2, 10);
+        });
+        it('should produce different results for different points', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10] });
+            const value1 = noise.noise([1.0, 1.0]);
+            const value2 = noise.noise([5.0, 5.0]);
+            expect(typeof value1).toBe('number');
+            expect(typeof value2).toBe('number');
+        });
+        it('should handle negative coordinates', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10] });
+            const value = noise.noise([-1.5, -2.3]);
+            expect(typeof value).toBe('number');
+        });
+        it('should handle large coordinates (wrapping)', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10] });
+            const value1 = noise.noise([1.5, 2.3]);
+            const value2 = noise.noise([11.5, 12.3]); // Should wrap
+            expect(value1).toBeCloseTo(value2, 10);
+        });
+        it('should produce smooth transitions', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10] });
+            const value1 = noise.noise([1.0, 1.0]);
+            const value2 = noise.noise([1.1, 1.0]);
+            const value3 = noise.noise([1.2, 1.0]);
+            // Values should change gradually (not jump dramatically)
+            expect(typeof value1).toBe('number');
+            expect(typeof value2).toBe('number');
+            expect(typeof value3).toBe('number');
+        });
+    });
+    describe('3D noise', () => {
+        it('should generate noise value for 3D coordinates', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
+            const value = noise.noise([1.5, 2.3, 3.7]);
+            expect(typeof value).toBe('number');
+            expect(value).toBeGreaterThanOrEqual(-2);
+            expect(value).toBeLessThanOrEqual(2);
+        });
+        it('should produce consistent results for same point', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
+            const value1 = noise.noise([2.3, 4.7, 1.2]);
+            const value2 = noise.noise([2.3, 4.7, 1.2]);
+            expect(value1).toBeCloseTo(value2, 10);
+        });
+        it('should produce different results for different points', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
+            const value1 = noise.noise([1.0, 1.0, 1.0]);
+            const value2 = noise.noise([5.0, 5.0, 5.0]);
+            expect(typeof value1).toBe('number');
+            expect(typeof value2).toBe('number');
+        });
+        it('should handle negative coordinates', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
+            const value = noise.noise([-1.5, -2.3, -3.7]);
+            expect(typeof value).toBe('number');
+        });
+        it('should handle large coordinates (wrapping)', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
+            const value1 = noise.noise([1.5, 2.3, 3.7]);
+            const value2 = noise.noise([11.5, 12.3, 13.7]); // Should wrap
+            expect(value1).toBeCloseTo(value2, 10);
+        });
+    });
+    describe('dimension validation', () => {
+        it('should throw error when noise dimension does not match grid dimension', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10] });
+            expect(() => noise.noise([1.0])).toThrow(); // 1D noise on 2D grid
+            expect(() => noise.noise([1.0, 1.0, 1.0])).toThrow(); // 3D noise on 2D grid
+        });
+        it('should allow 1D noise on 1D grid', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10] });
+            expect(() => noise.noise([1.0])).not.toThrow();
+        });
+        it('should allow 2D noise on 2D grid', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10] });
+            expect(() => noise.noise([1.0, 1.0])).not.toThrow();
+        });
+        it('should allow 3D noise on 3D grid', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
+            expect(() => noise.noise([1.0, 1.0, 1.0])).not.toThrow();
+        });
+    });
+    describe('seed behavior', () => {
+        it('should produce different results with different seeds', () => {
+            const noise1 = new index_1.PerlinNoise({ seed: 100, gridSize: [10, 10, 10] });
+            const noise2 = new index_1.PerlinNoise({ seed: 200, gridSize: [10, 10, 10] });
+            const value1 = noise1.noise([1.0, 1.0, 1.0]);
+            const value2 = noise2.noise([1.0, 1.0, 1.0]);
+            // They might be the same by chance, but very unlikely
+            expect(typeof value1).toBe('number');
+            expect(typeof value2).toBe('number');
+        });
+        it('should produce same results with same seed', () => {
+            const noise1 = new index_1.PerlinNoise({ seed: 500, gridSize: [10, 10, 10] });
+            const noise2 = new index_1.PerlinNoise({ seed: 500, gridSize: [10, 10, 10] });
+            const value1 = noise1.noise([2.5, 3.7, 1.2]);
+            const value2 = noise2.noise([2.5, 3.7, 1.2]);
+            expect(value1).toBeCloseTo(value2, 10);
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle zero coordinates', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
+            const value = noise.noise([0.0, 0.0, 0.0]);
+            expect(typeof value).toBe('number');
+        });
+        it('should handle very small coordinates', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
+            const value = noise.noise([0.0001, 0.0001, 0.0001]);
+            expect(typeof value).toBe('number');
+        });
+        it('should handle very large coordinates', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
+            const value = noise.noise([1000.5, 2000.3, 3000.7]);
+            expect(typeof value).toBe('number');
+        });
+        it('should handle coordinates at exact grid boundaries', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
+            const value = noise.noise([10.0, 10.0, 10.0]);
+            expect(typeof value).toBe('number');
+        });
+        it('should handle different grid sizes', () => {
+            const noise1 = new index_1.PerlinNoise({ seed: 123, gridSize: [5, 5, 5] });
+            const noise2 = new index_1.PerlinNoise({ seed: 123, gridSize: [20, 20, 20] });
+            const value1 = noise1.noise([1.0, 1.0, 1.0]);
+            const value2 = noise2.noise([1.0, 1.0, 1.0]);
+            // Different grid sizes with same seed should produce different results
+            expect(typeof value1).toBe('number');
+            expect(typeof value2).toBe('number');
+        });
+    });
+    describe('higher dimensions', () => {
+        it('should support 4D noise', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [5, 5, 5, 5] });
+            const value = noise.noise([1.0, 1.0, 1.0, 1.0]);
+            expect(typeof value).toBe('number');
+            expect(value).toBeGreaterThanOrEqual(-2);
+            expect(value).toBeLessThanOrEqual(2);
+        });
+        it('should support 5D noise', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [5, 5, 5, 5, 5] });
+            const value = noise.noise([1.0, 1.0, 1.0, 1.0, 1.0]);
+            expect(typeof value).toBe('number');
+        });
+        it('should support 10D noise (maximum)', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [2, 2, 2, 2, 2, 2, 2, 2, 2, 2] });
+            const value = noise.noise([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]);
+            expect(typeof value).toBe('number');
+        });
+        it('should produce consistent results for same point in higher dimensions', () => {
+            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [5, 5, 5, 5] });
+            const value1 = noise.noise([2.3, 4.7, 1.2, 3.5]);
+            const value2 = noise.noise([2.3, 4.7, 1.2, 3.5]);
+            expect(value1).toBeCloseTo(value2, 10);
+        });
+    });
+});

package/dist/__tests__/interpolation.test.d.ts

@@ -0,0 +1 @@
+export {};