@arvarus/perlin-noise 0.1.1

package/dist/__tests__/interpolation.test.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const interpolation_1 = require("../interpolation");
+describe('smoothstep', () => {
+    it('should return 0 for t = 0', () => {
+        expect((0, interpolation_1.smoothstep)(0)).toBe(0);
+    });
+    it('should return 1 for t = 1', () => {
+        expect((0, interpolation_1.smoothstep)(1)).toBe(1);
+    });
+    it('should return 0.5 for t = 0.5', () => {
+        expect((0, interpolation_1.smoothstep)(0.5)).toBe(0.5);
+    });
+    it('should be symmetric around 0.5', () => {
+        const t1 = 0.3;
+        const t2 = 0.7;
+        const s1 = (0, interpolation_1.smoothstep)(t1);
+        const s2 = (0, interpolation_1.smoothstep)(t2);
+        expect(s1 + s2).toBeCloseTo(1, 10);
+    });
+    it('should clamp values outside [0, 1]', () => {
+        expect((0, interpolation_1.smoothstep)(-1)).toBe(0);
+        expect((0, interpolation_1.smoothstep)(2)).toBe(1);
+    });
+    it('should have zero derivative at endpoints', () => {
+        // Numerical test of derivative near 0
+        const h = 0.0001;
+        const derivativeAt0 = ((0, interpolation_1.smoothstep)(h) - (0, interpolation_1.smoothstep)(0)) / h;
+        expect(derivativeAt0).toBeCloseTo(0, 2);
+        // Numerical test of derivative near 1
+        const derivativeAt1 = ((0, interpolation_1.smoothstep)(1) - (0, interpolation_1.smoothstep)(1 - h)) / h;
+        expect(derivativeAt1).toBeCloseTo(0, 2);
+    });
+    it('should be monotonically increasing', () => {
+        const values = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0];
+        for (let i = 1; i < values.length; i++) {
+            expect((0, interpolation_1.smoothstep)(values[i])).toBeGreaterThanOrEqual((0, interpolation_1.smoothstep)(values[i - 1]));
+        }
+    });
+});
+describe('calculateFractionalCoordinates', () => {
+    it('should calculate fractional coordinates for a 1D point', () => {
+        const point = [2.3];
+        const fractional = (0, interpolation_1.calculateFractionalCoordinates)(point);
+        expect(fractional).toHaveLength(1);
+        expect(fractional[0]).toBeCloseTo(0.3, 10);
+    });
+    it('should calculate fractional coordinates for a 2D point', () => {
+        const point = [1.7, 3.2];
+        const fractional = (0, interpolation_1.calculateFractionalCoordinates)(point);
+        expect(fractional).toHaveLength(2);
+        expect(fractional[0]).toBeCloseTo(0.7, 10);
+        expect(fractional[1]).toBeCloseTo(0.2, 10);
+    });
+    it('should return 0 for a point exactly on a grid node', () => {
+        const point = [2.0, 3.0];
+        const fractional = (0, interpolation_1.calculateFractionalCoordinates)(point);
+        expect(fractional[0]).toBe(0);
+        expect(fractional[1]).toBe(0);
+    });
+    it('should handle negative coordinates', () => {
+        const point = [-1.3];
+        const fractional = (0, interpolation_1.calculateFractionalCoordinates)(point);
+        // -1.3 is in cell [-2], so fractional coordinate is -1.3 - (-2) = 0.7
+        expect(fractional[0]).toBeCloseTo(0.7, 10);
+    });
+    it('should handle fractional coordinates close to 1', () => {
+        const point = [2.99];
+        const fractional = (0, interpolation_1.calculateFractionalCoordinates)(point);
+        expect(fractional[0]).toBeCloseTo(0.99, 10);
+    });
+});
+describe('interpolate1D', () => {
+    it('should return a0 for t = 0', () => {
+        expect((0, interpolation_1.interpolate1D)(5, 10, 0)).toBe(5);
+    });
+    it('should return a1 for t = 1', () => {
+        expect((0, interpolation_1.interpolate1D)(5, 10, 1)).toBe(10);
+    });
+    it('should return the average for t = 0.5', () => {
+        expect((0, interpolation_1.interpolate1D)(0, 10, 0.5)).toBeCloseTo(5, 10);
+    });
+    it('should interpolate correctly for different values', () => {
+        const result = (0, interpolation_1.interpolate1D)(0, 100, 0.3);
+        // For t=0.3, smoothstep(0.3) ≈ 0.216, so result ≈ 0 + 0.216 * 100 = 21.6
+        expect(result).toBeGreaterThan(0);
+        expect(result).toBeLessThan(100);
+    });
+    it('should handle negative values', () => {
+        expect((0, interpolation_1.interpolate1D)(-10, 10, 0.5)).toBeCloseTo(0, 10);
+    });
+    it('should be symmetric', () => {
+        const result1 = (0, interpolation_1.interpolate1D)(0, 10, 0.3);
+        const result2 = (0, interpolation_1.interpolate1D)(10, 0, 0.7);
+        expect(result1).toBeCloseTo(result2, 10);
+    });
+});
+describe('interpolateScalarValues', () => {
+    describe('1D interpolation', () => {
+        it('should interpolate between 2 scalar values for a 1D point', () => {
+            const scalarValues = [5, 10];
+            const point = [0.3]; // Fractional coordinate = 0.3
+            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
+            // Should be equivalent to interpolate1D(5, 10, 0.3)
+            const expected = (0, interpolation_1.interpolate1D)(5, 10, 0.3);
+            expect(result).toBeCloseTo(expected, 10);
+        });
+        it('should return the first value for a point at node 0', () => {
+            const scalarValues = [5, 10];
+            const point = [2.0]; // Exactly at node
+            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
+            expect(result).toBeCloseTo(5, 10);
+        });
+        it('should return the second value for a point at node 1', () => {
+            const scalarValues = [5, 10];
+            // Note: for point=[3.0], fractional coordinate is 0, so we're at node of cell [3]
+            // But scalar values are for cell [2], so we test with point=[2.999...]
+            const point2 = [2.999999];
+            const result2 = (0, interpolation_1.interpolateScalarValues)(scalarValues, point2);
+            expect(result2).toBeCloseTo(10, 2);
+        });
+        it('should throw error if number of values does not match', () => {
+            const scalarValues = [5, 10, 15]; // 3 values instead of 2
+            const point = [0.5];
+            expect(() => (0, interpolation_1.interpolateScalarValues)(scalarValues, point)).toThrow();
+        });
+    });
+    describe('2D interpolation', () => {
+        it('should interpolate between 4 scalar values for a 2D point', () => {
+            const scalarValues = [0, 10, 20, 30];
+            const point = [0.5, 0.5]; // Cell center
+            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
+            // At center, we should get approximately the average
+            expect(result).toBeGreaterThan(0);
+            expect(result).toBeLessThan(30);
+        });
+        it('should return corner value for a point exactly on a corner', () => {
+            const scalarValues = [5, 10, 15, 20];
+            const point = [2.0, 3.0]; // Exactly at corner [2,3]
+            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
+            // Should return the first value (bottom-left corner)
+            expect(result).toBeCloseTo(5, 10);
+        });
+        it('should interpolate correctly for different positions', () => {
+            const scalarValues = [0, 1, 2, 3];
+            const point = [0.0, 0.0]; // Bottom-left corner
+            const result1 = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
+            expect(result1).toBeCloseTo(0, 10);
+            const point2 = [0.999, 0.999]; // Close to top-right corner
+            const result2 = (0, interpolation_1.interpolateScalarValues)(scalarValues, point2);
+            expect(result2).toBeCloseTo(3, 1);
+        });
+        it('should throw error if number of values does not match', () => {
+            const scalarValues = [0, 1, 2]; // 3 values instead of 4
+            const point = [0.5, 0.5];
+            expect(() => (0, interpolation_1.interpolateScalarValues)(scalarValues, point)).toThrow();
+        });
+    });
+    describe('3D interpolation', () => {
+        it('should interpolate between 8 scalar values for a 3D point', () => {
+            const scalarValues = [0, 1, 2, 3, 4, 5, 6, 7];
+            const point = [0.5, 0.5, 0.5]; // Cell center
+            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
+            expect(result).toBeGreaterThanOrEqual(0);
+            expect(result).toBeLessThanOrEqual(7);
+        });
+        it('should return corner value for a point exactly on a corner', () => {
+            const scalarValues = [10, 20, 30, 40, 50, 60, 70, 80];
+            const point = [1.0, 2.0, 3.0]; // Exactly at corner
+            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
+            // Should return the first value
+            expect(result).toBeCloseTo(10, 10);
+        });
+        it('should throw error if number of values does not match', () => {
+            const scalarValues = [0, 1, 2, 3, 4, 5, 6]; // 7 values instead of 8
+            const point = [0.5, 0.5, 0.5];
+            expect(() => (0, interpolation_1.interpolateScalarValues)(scalarValues, point)).toThrow();
+        });
+    });
+    describe('higher dimensions', () => {
+        it('should interpolate between 16 scalar values for a 4D point', () => {
+            const scalarValues = Array.from({ length: 16 }, (_, i) => i);
+            const point = [0.5, 0.5, 0.5, 0.5];
+            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
+            expect(result).toBeGreaterThanOrEqual(0);
+            expect(result).toBeLessThanOrEqual(15);
+        });
+        it('should interpolate between 32 scalar values for a 5D point', () => {
+            const scalarValues = Array.from({ length: 32 }, (_, i) => i);
+            const point = [0.5, 0.5, 0.5, 0.5, 0.5];
+            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
+            expect(result).toBeGreaterThanOrEqual(0);
+            expect(result).toBeLessThanOrEqual(31);
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle all identical scalar values', () => {
+            const scalarValues = [5, 5, 5, 5];
+            const point = [0.7, 0.3];
+            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
+            expect(result).toBe(5);
+        });
+        it('should handle negative scalar values', () => {
+            const scalarValues = [-10, -5, 5, 10];
+            const point = [0.5, 0.5];
+            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
+            expect(result).toBeGreaterThan(-10);
+            expect(result).toBeLessThan(10);
+        });
+        it('should handle very large scalar values', () => {
+            const scalarValues = [1000, 2000, 3000, 4000];
+            const point = [0.5, 0.5];
+            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
+            expect(result).toBeGreaterThan(1000);
+            expect(result).toBeLessThan(4000);
+        });
+        it('should produce consistent results for the same point', () => {
+            const scalarValues = [0, 1, 2, 3];
+            const point = [0.7, 0.3];
+            const result1 = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
+            const result2 = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
+            expect(result1).toBeCloseTo(result2, 10);
+        });
+        it('should produce different results for different points', () => {
+            const scalarValues = [0, 1, 2, 3];
+            const point1 = [0.1, 0.1];
+            const point2 = [0.9, 0.9];
+            const result1 = (0, interpolation_1.interpolateScalarValues)(scalarValues, point1);
+            const result2 = (0, interpolation_1.interpolateScalarValues)(scalarValues, point2);
+            expect(result1).not.toBeCloseTo(result2, 10);
+        });
+    });
+});
+describe('scaleNoiseValue', () => {
+    it('should return unchanged value with scale factor of 1.0', () => {
+        expect((0, interpolation_1.scaleNoiseValue)(0.5)).toBe(0.5);
+        expect((0, interpolation_1.scaleNoiseValue)(-0.3)).toBe(-0.3);
+        expect((0, interpolation_1.scaleNoiseValue)(1.0)).toBe(1.0);
+    });
+    it('should scale correctly with custom scale factor', () => {
+        expect((0, interpolation_1.scaleNoiseValue)(0.5, 2.0)).toBe(1.0);
+        expect((0, interpolation_1.scaleNoiseValue)(0.5, 0.5)).toBe(0.25);
+        expect((0, interpolation_1.scaleNoiseValue)(-0.5, 2.0)).toBe(-1.0);
+    });
+    it('should handle scale factor of 0', () => {
+        expect((0, interpolation_1.scaleNoiseValue)(0.5, 0)).toBe(0);
+        expect((0, interpolation_1.scaleNoiseValue)(-0.3, 0)).toBeCloseTo(0, 10);
+    });
+    it('should handle negative values', () => {
+        expect((0, interpolation_1.scaleNoiseValue)(-0.5, 2.0)).toBe(-1.0);
+        expect((0, interpolation_1.scaleNoiseValue)(-1.0, 0.5)).toBe(-0.5);
+    });
+});

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

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

package/dist/__tests__/scalar.test.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const grid_1 = require("../grid");
+const scalar_1 = require("../scalar");
+describe('calculateScalarValues', () => {
+    describe('1D grid', () => {
+        it('should return 2 scalar values for a point in 1D (2 vertices)', () => {
+            const grid = (0, grid_1.generateGradientGrid)(1, [5], 123);
+            const point = [2.5]; // Point in cell [2]
+            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
+            expect(scalarValues).toHaveLength(2); // 2^1 = 2 vertices
+        });
+        it('should calculate correct dot products for 1D', () => {
+            const grid = (0, grid_1.generateGradientGrid)(1, [5], 123);
+            const point = [1.3]; // Point in cell [1]
+            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
+            // Cell [1] has vertices at [1] and [2]
+            const gradient1 = grid.get('1');
+            const gradient2 = grid.get('2');
+            // Distance vectors: point - vertex
+            const distance1 = point[0] - 1; // 1.3 - 1 = 0.3
+            const distance2 = point[0] - 2; // 1.3 - 2 = -0.7
+            // Dot products: gradient * distance
+            const expected1 = gradient1 * distance1;
+            const expected2 = gradient2 * distance2;
+            expect(scalarValues[0]).toBeCloseTo(expected1, 10);
+            expect(scalarValues[1]).toBeCloseTo(expected2, 10);
+        });
+        it('should handle point at cell boundary', () => {
+            const grid = (0, grid_1.generateGradientGrid)(1, [5], 123);
+            const point = [2.0]; // Exactly at cell boundary (cell [2])
+            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
+            expect(scalarValues).toHaveLength(2);
+            // Cell [2] has vertices at [2] (i=0) and [3] (i=1)
+            // Distance to vertex [2] should be 0
+            const gradient2 = grid.get('2');
+            expect(scalarValues[0]).toBeCloseTo(gradient2 * 0, 10); // First vertex is [2]
+        });
+        it('should handle negative coordinates', () => {
+            // Create a grid that covers negative coordinates by using a larger grid
+            // and testing a point that maps to a valid cell
+            const grid = (0, grid_1.generateGradientGrid)(1, [10], 123);
+            const point = [0.5]; // Cell [0], which is valid
+            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
+            expect(scalarValues).toHaveLength(2);
+            // Verify vertices are [0] and [1]
+            expect(grid.has('0')).toBe(true);
+            expect(grid.has('1')).toBe(true);
+        });
+        it('should throw error when point is outside grid bounds', () => {
+            const grid = (0, grid_1.generateGradientGrid)(1, [5], 123);
+            const point = [10.0]; // Outside grid (max is 5, so vertices go up to 6)
+            expect(() => (0, scalar_1.calculateScalarValues)(grid, point)).toThrow();
+        });
+    });
+    describe('2D grid', () => {
+        it('should return 4 scalar values for a point in 2D (4 vertices)', () => {
+            const grid = (0, grid_1.generateGradientGrid)(2, [5, 5], 123);
+            const point = [2.5, 3.2]; // Point in cell [2, 3]
+            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
+            expect(scalarValues).toHaveLength(4); // 2^2 = 4 vertices
+        });
+        it('should calculate correct dot products for 2D', () => {
+            const grid = (0, grid_1.generateGradientGrid)(2, [5, 5], 123);
+            const point = [1.3, 2.7]; // Point in cell [1, 2]
+            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
+            // Cell [1, 2] has vertices in order: [1,2] (i=0), [2,2] (i=1), [1,3] (i=2), [2,3] (i=3)
+            const gradient12 = grid.get('1,2');
+            const gradient22 = grid.get('2,2');
+            const gradient13 = grid.get('1,3');
+            const gradient23 = grid.get('2,3');
+            // Distance vectors: point - vertex
+            const distance12 = [point[0] - 1, point[1] - 2]; // [0.3, 0.7]
+            const distance22 = [point[0] - 2, point[1] - 2]; // [-0.7, 0.7]
+            const distance13 = [point[0] - 1, point[1] - 3]; // [0.3, -0.3]
+            const distance23 = [point[0] - 2, point[1] - 3]; // [-0.7, -0.3]
+            // Dot products
+            const expected12 = gradient12[0] * distance12[0] + gradient12[1] * distance12[1];
+            const expected22 = gradient22[0] * distance22[0] + gradient22[1] * distance22[1];
+            const expected13 = gradient13[0] * distance13[0] + gradient13[1] * distance13[1];
+            const expected23 = gradient23[0] * distance23[0] + gradient23[1] * distance23[1];
+            expect(scalarValues[0]).toBeCloseTo(expected12, 10);
+            expect(scalarValues[1]).toBeCloseTo(expected22, 10);
+            expect(scalarValues[2]).toBeCloseTo(expected13, 10);
+            expect(scalarValues[3]).toBeCloseTo(expected23, 10);
+        });
+        it('should handle point at cell corner', () => {
+            const grid = (0, grid_1.generateGradientGrid)(2, [5, 5], 123);
+            const point = [2.0, 3.0]; // Exactly at vertex [2, 3] in cell [2, 3]
+            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
+            expect(scalarValues).toHaveLength(4);
+            // Cell [2, 3] has vertices in order: [2,3] (i=0), [3,3] (i=1), [2,4] (i=2), [3,4] (i=3)
+            // Distance to vertex [2, 3] should be [0, 0]
+            expect(scalarValues[0]).toBeCloseTo(0, 10); // dot product with [0, 0] is 0
+        });
+        it('should handle decimal coordinates correctly', () => {
+            const grid = (0, grid_1.generateGradientGrid)(2, [5, 5], 123);
+            const point = [0.1, 0.9]; // Should be in cell [0, 0]
+            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
+            expect(scalarValues).toHaveLength(4);
+            // All vertices should be in cell [0, 0]: [0,0], [0,1], [1,0], [1,1]
+            expect(grid.has('0,0')).toBe(true);
+            expect(grid.has('0,1')).toBe(true);
+            expect(grid.has('1,0')).toBe(true);
+            expect(grid.has('1,1')).toBe(true);
+        });
+        it('should throw error when point is outside grid bounds', () => {
+            const grid = (0, grid_1.generateGradientGrid)(2, [3, 3], 123);
+            const point = [10.0, 10.0]; // Outside grid
+            expect(() => (0, scalar_1.calculateScalarValues)(grid, point)).toThrow();
+        });
+    });
+    describe('3D grid', () => {
+        it('should return 8 scalar values for a point in 3D (8 vertices)', () => {
+            const grid = (0, grid_1.generateGradientGrid)(3, [5, 5, 5], 123);
+            const point = [2.5, 3.2, 1.8]; // Point in cell [2, 3, 1]
+            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
+            expect(scalarValues).toHaveLength(8); // 2^3 = 8 vertices
+        });
+        it('should calculate correct dot products for 3D', () => {
+            const grid = (0, grid_1.generateGradientGrid)(3, [5, 5, 5], 123);
+            const point = [1.0, 1.0, 1.0]; // Point in cell [1, 1, 1]
+            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
+            // Verify we get 8 values
+            expect(scalarValues).toHaveLength(8);
+            // Verify all vertices exist in grid
+            const cell = [1, 1, 1];
+            for (let i = 0; i < 8; i++) {
+                const vertex = [
+                    cell[0] + ((i >> 0) & 1),
+                    cell[1] + ((i >> 1) & 1),
+                    cell[2] + ((i >> 2) & 1),
+                ];
+                const key = vertex.join(',');
+                expect(grid.has(key)).toBe(true);
+            }
+        });
+        it('should handle point at cell center', () => {
+            const grid = (0, grid_1.generateGradientGrid)(3, [5, 5, 5], 123);
+            const point = [1.5, 1.5, 1.5]; // Center of cell [1, 1, 1]
+            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
+            expect(scalarValues).toHaveLength(8);
+            // All distance vectors should have components of ±0.5
+            expect(scalarValues.every(val => typeof val === 'number')).toBe(true);
+        });
+    });
+    describe('higher dimensions', () => {
+        it('should return 16 scalar values for a point in 4D (16 vertices)', () => {
+            const grid = (0, grid_1.generateGradientGrid)(4, [3, 3, 3, 3], 123);
+            const point = [1.0, 1.0, 1.0, 1.0]; // Point in cell [1, 1, 1, 1]
+            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
+            expect(scalarValues).toHaveLength(16); // 2^4 = 16 vertices
+        });
+        it('should return 32 scalar values for a point in 5D (32 vertices)', () => {
+            const grid = (0, grid_1.generateGradientGrid)(5, [2, 2, 2, 2, 2], 123);
+            const point = [1.0, 1.0, 1.0, 1.0, 1.0]; // Point in cell [1, 1, 1, 1, 1]
+            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
+            expect(scalarValues).toHaveLength(32); // 2^5 = 32 vertices
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle point at origin', () => {
+            const grid = (0, grid_1.generateGradientGrid)(2, [5, 5], 123);
+            const point = [0.0, 0.0]; // Cell [0, 0]
+            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
+            expect(scalarValues).toHaveLength(4);
+            expect(grid.has('0,0')).toBe(true);
+            expect(grid.has('0,1')).toBe(true);
+            expect(grid.has('1,0')).toBe(true);
+            expect(grid.has('1,1')).toBe(true);
+        });
+        it('should handle very small coordinates', () => {
+            const grid = (0, grid_1.generateGradientGrid)(2, [5, 5], 123);
+            const point = [0.0001, 0.0001]; // Cell [0, 0]
+            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
+            expect(scalarValues).toHaveLength(4);
+        });
+        it('should handle large coordinates within bounds', () => {
+            const grid = (0, grid_1.generateGradientGrid)(2, [10, 10], 123);
+            const point = [9.9, 9.9]; // Cell [9, 9], should have vertices at [9,9], [9,10], [10,9], [10,10]
+            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
+            expect(scalarValues).toHaveLength(4);
+            // Grid size is 10, so vertices go up to 10
+            expect(grid.has('9,9')).toBe(true);
+            expect(grid.has('9,10')).toBe(true);
+            expect(grid.has('10,9')).toBe(true);
+            expect(grid.has('10,10')).toBe(true);
+        });
+        it('should produce consistent results for same point', () => {
+            const grid = (0, grid_1.generateGradientGrid)(2, [5, 5], 123);
+            const point = [2.5, 3.2];
+            const scalarValues1 = (0, scalar_1.calculateScalarValues)(grid, point);
+            const scalarValues2 = (0, scalar_1.calculateScalarValues)(grid, point);
+            expect(scalarValues1).toHaveLength(scalarValues2.length);
+            for (let i = 0; i < scalarValues1.length; i++) {
+                expect(scalarValues1[i]).toBeCloseTo(scalarValues2[i], 10);
+            }
+        });
+        it('should produce different results for different points', () => {
+            const grid = (0, grid_1.generateGradientGrid)(2, [5, 5], 123);
+            const point1 = [1.0, 1.0];
+            const point2 = [2.0, 2.0];
+            const scalarValues1 = (0, scalar_1.calculateScalarValues)(grid, point1);
+            const scalarValues2 = (0, scalar_1.calculateScalarValues)(grid, point2);
+            // They might have some same values, but at least one should be different
+            expect(scalarValues1).toHaveLength(4);
+            expect(scalarValues2).toHaveLength(4);
+        });
+    });
+});

package/dist/grid.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Grid generation for Perlin noise
+ * Generates a grid with random gradient vectors at each intersection
+ */
+export type GridDimension = number;
+export type GradientVector = number | number[];
+/**
+ * Generates a grid with gradient vectors at each intersection
+ *
+ * @param dimension - The dimension of the grid (any positive integer)
+ * @param size - Array of sizes for each dimension (number of cells per dimension)
+ * @param seed - Optional seed for random number generation
+ * @returns A Map with grid coordinates as keys and gradient vectors as values
+ */
+export declare function generateGradientGrid(dimension: GridDimension, size: number[], seed?: number): Map<string, GradientVector>;
+/**
+ * Gets the gradient vector at a specific grid intersection
+ *
+ * @param grid - The gradient grid
+ * @param coordinates - The grid coordinates as an array
+ * @returns The gradient vector at the specified coordinates, or undefined if not found
+ */
+export declare function getGradientAt(grid: Map<string, GradientVector>, coordinates: number[]): GradientVector | undefined;

package/dist/grid.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * Grid generation for Perlin noise
+ * Generates a grid with random gradient vectors at each intersection
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGradientGrid = generateGradientGrid;
+exports.getGradientAt = getGradientAt;
+/**
+ * Generates a random number between min and max (inclusive)
+ */
+function randomRange(min, max, rng) {
+    return min + rng() * (max - min);
+}
+/**
+ * Generates a random number between 0 and 1 using a seeded random number generator
+ */
+function createSeededRNG(seed) {
+    let value = seed;
+    return () => {
+        value = (value * 9301 + 49297) % 233280;
+        return value / 233280;
+    };
+}
+/**
+ * Normalizes a vector to unit length
+ */
+function normalizeVector(vector) {
+    const magnitude = Math.sqrt(vector.reduce((sum, val) => sum + val * val, 0));
+    if (magnitude === 0) {
+        return vector.map(() => 0);
+    }
+    return vector.map(val => val / magnitude);
+}
+/**
+ * Generates a random unit-length gradient vector for the given dimension
+ */
+function generateUnitGradient(dimension, rng) {
+    const vector = [];
+    for (let i = 0; i < dimension; i++) {
+        vector.push(randomRange(-1, 1, rng));
+    }
+    return normalizeVector(vector);
+}
+/**
+ * Recursively generates all coordinate combinations for a given dimension
+ */
+function generateCoordinates(dimension, gridPoints, currentCoords = []) {
+    if (currentCoords.length === dimension) {
+        return [currentCoords];
+    }
+    const coordinates = [];
+    const currentDim = currentCoords.length;
+    const pointsForThisDim = gridPoints[currentDim];
+    for (let i = 0; i < pointsForThisDim; i++) {
+        const newCoords = [...currentCoords, i];
+        coordinates.push(...generateCoordinates(dimension, gridPoints, newCoords));
+    }
+    return coordinates;
+}
+/**
+ * Generates a grid with gradient vectors at each intersection
+ *
+ * @param dimension - The dimension of the grid (any positive integer)
+ * @param size - Array of sizes for each dimension (number of cells per dimension)
+ * @param seed - Optional seed for random number generation
+ * @returns A Map with grid coordinates as keys and gradient vectors as values
+ */
+function generateGradientGrid(dimension, size, seed = Math.floor(Math.random() * 1000000)) {
+    const grid = new Map();
+    const rng = createSeededRNG(seed);
+    if (!Number.isInteger(dimension) || dimension < 1) {
+        throw new Error(`Dimension must be a positive integer, got ${dimension}`);
+    }
+    if (size.length !== dimension) {
+        throw new Error(`Size array length (${size.length}) must match dimension (${dimension})`);
+    }
+    // Calculate the number of grid points for each dimension (size + 1 for intersections)
+    const gridPoints = size.map(s => s + 1);
+    const coordinates = generateCoordinates(dimension, gridPoints);
+    for (const coord of coordinates) {
+        const key = coord.join(',');
+        let gradient;
+        if (dimension === 1) {
+            // 1D case: random scalars between -1 and 1
+            gradient = randomRange(-1, 1, rng);
+        }
+        else {
+            // Multi-dimensional case: unit-length vectors
+            const vector = generateUnitGradient(dimension, rng);
+            gradient = vector;
+        }
+        grid.set(key, gradient);
+    }
+    return grid;
+}
+/**
+ * Gets the gradient vector at a specific grid intersection
+ *
+ * @param grid - The gradient grid
+ * @param coordinates - The grid coordinates as an array
+ * @returns The gradient vector at the specified coordinates, or undefined if not found
+ */
+function getGradientAt(grid, coordinates) {
+    const key = coordinates.join(',');
+    return grid.get(key);
+}

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @arvarus/perlin-noise
+ * Perlin noise implementation in TypeScript
+ */
+export { generateGradientGrid, getGradientAt } from './grid';
+export type { GridDimension, GradientVector } from './grid';
+/**
+ * Configuration options for PerlinNoise
+ */
+export interface PerlinNoiseOptions {
+    /**
+     * Seed for random number generation
+     */
+    seed?: number;
+    /**
+     * Grid size for each dimension (default: [64, 64, 64])
+     * The grid will wrap around, so values can be smaller for repeating patterns
+     * Supports 1 to 10 dimensions
+     */
+    gridSize?: number[];
+}
+/**
+ * PerlinNoise class for generating Perlin noise values
+ */
+export declare class PerlinNoise {
+    private grid;
+    private seed;
+    private gridSize;
+    private dimension;
+    /**
+     * Creates a new PerlinNoise instance
+     *
+     * @param options - Configuration options (seed and grid size)
+     */
+    constructor(options?: PerlinNoiseOptions);
+    /**
+     * Generate noise value at given coordinates
+     * Supports noise generation for any dimension (1 to 10)
+     *
+     * @param coordinates - Array of coordinates, length must match grid dimension
+     * @returns Noise value in the range approximately [-1, 1]
+     */
+    noise(coordinates: number[]): number;
+}