@mojir/lits 2.1.8 → 2.1.10

package/dist/testFramework.js

@@ -804,7 +804,7 @@ function deepEqual(a, b, sourceCodeInfo) {
     if (a === b)
         return true;
     if (typeof a === 'number' && typeof b === 'number')
-        return Math.abs(a - b) < Number.EPSILON;
+        return Math.abs(a - b) < 1e-10;
     if (Array.isArray(a) && Array.isArray(b)) {
         if (a.length !== b.length)
             return false;
@@ -823,7 +823,7 @@ function deepEqual(a, b, sourceCodeInfo) {
             return false;
         for (var i = 0; i < aKeys.length; i += 1) {
             var key = asString(aKeys[i], sourceCodeInfo);
-            if (!deepEqual(toAny(a[key]), toAny(b[key]), sourceCodeInfo))
+            if (!deepEqual(a[key], b[key], sourceCodeInfo))
                 return false;
         }
         return true;
@@ -2288,6 +2288,28 @@ function assertVector(vector, sourceCodeInfo) {
         throw new LitsError("Expected a vector, but got ".concat(vector), sourceCodeInfo);
     }
 }
+function is2dVector(vector) {
+    if (!isVector(vector)) {
+        return false;
+    }
+    return vector.length === 2;
+}
+function assert2dVector(vector, sourceCodeInfo) {
+    if (!is2dVector(vector)) {
+        throw new LitsError("Expected a 2d vector, but got ".concat(vector), sourceCodeInfo);
+    }
+}
+function is3dVector(vector) {
+    if (!isVector(vector)) {
+        return false;
+    }
+    return vector.length === 3;
+}
+function assert3dVector(vector, sourceCodeInfo) {
+    if (!is3dVector(vector)) {
+        throw new LitsError("Expected a 3d vector, but got ".concat(vector), sourceCodeInfo);
+    }
+}
 function assertNonEmptyVector(vector, sourceCodeInfo) {
     assertVector(vector, sourceCodeInfo);
     if (vector.length === 0) {
@@ -4668,6 +4690,24 @@ var gridNormalExpression = {
         },
         paramCount: 1,
     },
+    'grid:fill': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 3), rows = _b[0], cols = _b[1], value = _b[2];
+            assertNumber(rows, sourceCodeInfo, { integer: true, positive: true });
+            assertNumber(cols, sourceCodeInfo, { integer: true, positive: true });
+            assertAny(value, sourceCodeInfo);
+            var result = [];
+            for (var i = 0; i < rows; i += 1) {
+                var row = [];
+                for (var j = 0; j < cols; j += 1) {
+                    row.push(value);
+                }
+                result.push(row);
+            }
+            return result;
+        },
+        paramCount: 3,
+    },
     'grid:generate': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a, 3), rows = _c[0], cols = _c[1], generator = _c[2];
@@ -6612,7 +6652,137 @@ function extractOverlappingSegments(vectorA, vectorB, lag) {
     return [segmentA, segmentB];
 }
 
+function getUnit(value, sourceCodeInfo) {
+    if (value.length === 0) {
+        return value;
+    }
+    var length = Math.sqrt(value.reduce(function (acc, item) { return acc + Math.pow(item, 2); }, 0));
+    if (approxZero(length)) {
+        throw new LitsError('The vector must not be zero', sourceCodeInfo);
+    }
+    return value.map(function (item) { return item / length; });
+}
+
+function dot(vector1, vector2) {
+    return vector1.reduce(function (acc, item, index) { return acc + item * vector2[index]; }, 0);
+}
+
+function subtract(vector1, vector2) {
+    return vector1.map(function (item, index) { return item - vector2[index]; });
+}
+
+function scale(vector, scalar) {
+    return vector.map(function (item) { return item * scalar; });
+}
+
 var linearAlgebraNormalExpression = {
+    'lin:rotate2d': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), vector = _b[0], radians = _b[1];
+            assert2dVector(vector, sourceCodeInfo);
+            if (isZeroVector(vector)) {
+                return vector;
+            }
+            assertNumber(radians, sourceCodeInfo, { finite: true });
+            var cosTheta = Math.cos(radians);
+            var sinTheta = Math.sin(radians);
+            return [
+                vector[0] * cosTheta - vector[1] * sinTheta,
+                vector[0] * sinTheta + vector[1] * cosTheta,
+            ];
+        },
+        paramCount: 2,
+    },
+    'lin:rotate3d': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 3), vector = _b[0], axis = _b[1], radians = _b[2];
+            assert3dVector(vector, sourceCodeInfo);
+            if (isZeroVector(vector)) {
+                return vector;
+            }
+            assertNumber(radians, sourceCodeInfo, { finite: true });
+            assert3dVector(axis, sourceCodeInfo);
+            if (isZeroVector(axis)) {
+                throw new LitsError('Rotation axis must not be zero', sourceCodeInfo);
+            }
+            var cosTheta = Math.cos(radians);
+            var sinTheta = Math.sin(radians);
+            var _c = __read(getUnit(axis, sourceCodeInfo), 3), u = _c[0], v = _c[1], w = _c[2];
+            var dotProduct = vector[0] * u + vector[1] * v + vector[2] * w;
+            return [
+                dotProduct * u * (1 - cosTheta) + vector[0] * cosTheta + (-w * vector[1] + v * vector[2]) * sinTheta,
+                dotProduct * v * (1 - cosTheta) + vector[1] * cosTheta + (w * vector[0] - u * vector[2]) * sinTheta,
+                dotProduct * w * (1 - cosTheta) + vector[2] * cosTheta + (-v * vector[0] + u * vector[1]) * sinTheta,
+            ];
+        },
+        paramCount: 3,
+    },
+    'lin:reflect': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), vector = _b[0], normal = _b[1];
+            assertVector(vector, sourceCodeInfo);
+            assertVector(normal, sourceCodeInfo);
+            if (vector.length !== normal.length) {
+                throw new LitsError('Vectors must be of the same length', sourceCodeInfo);
+            }
+            if (isZeroVector(normal)) {
+                throw new LitsError('Reflection normal must not be zero', sourceCodeInfo);
+            }
+            if (isZeroVector(vector)) {
+                return vector;
+            }
+            var unitNormal = getUnit(normal, sourceCodeInfo);
+            var doubleDot = 2 * dot(vector, unitNormal);
+            return subtract(vector, scale(unitNormal, doubleDot));
+        },
+        paramCount: 2,
+    },
+    'lin:refract': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 3), vector = _b[0], normal = _b[1], eta = _b[2];
+            assertVector(vector, sourceCodeInfo);
+            assertVector(normal, sourceCodeInfo);
+            assertNumber(eta, sourceCodeInfo, { finite: true, positive: true });
+            if (vector.length !== normal.length) {
+                throw new LitsError('Vectors must be of the same length', sourceCodeInfo);
+            }
+            if (isZeroVector(normal)) {
+                throw new LitsError('Refraction normal must not be zero', sourceCodeInfo);
+            }
+            if (isZeroVector(vector)) {
+                return vector;
+            }
+            // Make sure vectors are normalized
+            var normalizedV = getUnit(vector, sourceCodeInfo);
+            var normalizedNormal = getUnit(normal, sourceCodeInfo);
+            // Calculate dot product between incident vector and normal
+            var dotProduct = dot(normalizedV, normalizedNormal);
+            // Calculate discriminant
+            var discriminant = 1 - eta * eta * (1 - dotProduct * dotProduct);
+            // Check for total internal reflection
+            if (discriminant < 0) {
+                return vector; // Total internal reflection occurs
+            }
+            // Calculate the refracted vector
+            var scaledIncident = scale(normalizedV, eta);
+            var scaledNormal = scale(normalizedNormal, eta * dotProduct + Math.sqrt(discriminant));
+            return subtract(scaledIncident, scaledNormal);
+        },
+        paramCount: 3,
+    },
+    'lin:lerp': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 3), vectorA = _b[0], vectorB = _b[1], t = _b[2];
+            assertVector(vectorA, sourceCodeInfo);
+            assertVector(vectorB, sourceCodeInfo);
+            assertNumber(t, sourceCodeInfo, { finite: true });
+            if (vectorA.length !== vectorB.length) {
+                throw new LitsError('Vectors must be of the same length', sourceCodeInfo);
+            }
+            return vectorA.map(function (val, i) { return val + (vectorB[i] - val) * t; });
+        },
+        paramCount: 3,
+    },
     'lin:dot': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), vectorA = _b[0], vectorB = _b[1];
@@ -6621,7 +6791,7 @@ var linearAlgebraNormalExpression = {
             if (vectorA.length !== vectorB.length) {
                 throw new LitsError('Vectors must be of the same length', sourceCodeInfo);
             }
-            return vectorA.reduce(function (acc, val, i) { return acc + val * vectorB[i]; }, 0);
+            return dot(vectorA, vectorB);
         },
         paramCount: 2,
     },
@@ -6702,16 +6872,10 @@ var linearAlgebraNormalExpression = {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), vector = _b[0];
             assertVector(vector, sourceCodeInfo);
-            if (vector.length === 0) {
-                return [];
-            }
-            var norm = Math.sqrt(vector.reduce(function (acc, val) { return acc + Math.pow(val, 2); }, 0));
-            if (norm === 0) {
-                return vector.map(function () { return 0; });
-            }
-            return vector.map(function (val) { return val / norm; });
+            return getUnit(vector, sourceCodeInfo);
         },
         paramCount: 1,
+        aliases: ['lin:unit', 'lin:normalize'],
     },
     'lin:normalize-log': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -6838,7 +7002,7 @@ var linearAlgebraNormalExpression = {
             return Math.sqrt(vector.reduce(function (acc, val) { return acc + val * val; }, 0));
         },
         paramCount: 1,
-        aliases: ['lin:l2-norm', 'lin:magnitude'],
+        aliases: ['lin:l2-norm', 'lin:length'],
     },
     'lin:manhattan-distance': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -12308,6 +12472,7 @@ function evaluateReservedSymbol(node) {
     return asNonUndefined(value, node[2]);
 }
 function evaluateNormalExpression(node, contextStack) {
+    var _a, _b;
     var sourceCodeInfo = node[2];
     var paramNodes = node[1][1];
     var params = [];
@@ -12333,14 +12498,14 @@ function evaluateNormalExpression(node, contextStack) {
         var nameSymbol = node[1][0];
         if (placeholders.length > 0) {
             var fn = evaluateNode(nameSymbol, contextStack);
-            var partialFunction = {
-                '^^fn^^': true,
-                'function': asFunctionLike(fn, sourceCodeInfo),
-                'functionType': 'Partial',
-                params: params,
-                placeholders: placeholders,
-                sourceCodeInfo: sourceCodeInfo,
-            };
+            var partialFunction = (_a = {},
+                _a[FUNCTION_SYMBOL] = true,
+                _a.function = asFunctionLike(fn, sourceCodeInfo),
+                _a.functionType = 'Partial',
+                _a.params = params,
+                _a.placeholders = placeholders,
+                _a.sourceCodeInfo = sourceCodeInfo,
+                _a);
             return partialFunction;
         }
         if (isNormalBuiltinSymbolNode(nameSymbol)) {
@@ -12360,14 +12525,14 @@ function evaluateNormalExpression(node, contextStack) {
         var fnNode = node[1][0];
         var fn = asFunctionLike(evaluateNode(fnNode, contextStack), sourceCodeInfo);
         if (placeholders.length > 0) {
-            var partialFunction = {
-                '^^fn^^': true,
-                'function': asFunctionLike(fn, sourceCodeInfo),
-                'functionType': 'Partial',
-                params: params,
-                placeholders: placeholders,
-                sourceCodeInfo: sourceCodeInfo,
-            };
+            var partialFunction = (_b = {},
+                _b[FUNCTION_SYMBOL] = true,
+                _b.function = asFunctionLike(fn, sourceCodeInfo),
+                _b.functionType = 'Partial',
+                _b.params = params,
+                _b.placeholders = placeholders,
+                _b.sourceCodeInfo = sourceCodeInfo,
+                _b);
             return partialFunction;
         }
         return executeFunction(fn, params, contextStack, sourceCodeInfo);