mapbox-gl-function - npm Package Compare versions

Comparing version 1.0.0 to 2.0.0

index.js

 'use strict';
 
-function constant(value) {
-    return function() {
-        return value;
+var GLOBAL_ATTRIBUTE_PREFIX = '$';
+
+module.exports = create;
+module.exports.is = is;
+
+function create(parameters) {
+    var property = parameters.property !== undefined ? parameters.property : '$zoom';
+
+    var feature, global;
+    var isFeatureConstant = false;
+    var isGlobalConstant = false;
+    if (!is(parameters)) {
+        global = function() { return feature; };
+        feature = function() { return parameters; };
+        isGlobalConstant = true;
+
+    } else if (property[0] === GLOBAL_ATTRIBUTE_PREFIX) {
+        global = function(values) {
+            var value = evaluate(parameters, values[property]);
+            feature = function() { return value; };
+            feature.isConstant = isFeatureConstant;
+            feature.isGlobalConstant  = isGlobalConstant;
+            feature.isFeatureConstant = isFeatureConstant;
+            return feature;
+        };
+        isFeatureConstant = true;
+
+    } else {
+        global = function() { return feature; };
+        feature = function(values) { return evaluate(parameters, values[property]); };
     }
+
+    if (isGlobalConstant) isFeatureConstant = true;
+
+    global.isConstant = isGlobalConstant;
+    global.isGlobalConstant = isGlobalConstant;
+    global.isFeatureConstant = isFeatureConstant;
+
+    if (feature) {
+        feature.isConstant = isFeatureConstant;
+        feature.isGlobalConstant  = isGlobalConstant;
+        feature.isFeatureConstant = isFeatureConstant;
+    }
+
+    return global;
 }
 
-function interpolateNumber(a, b, t) {
-    return (a * (1 - t)) + (b * t);
+function evaluate(parameters, value) {
+    if (value === undefined) {
+        return parameters.range[0];
+    } else if (!parameters.type || parameters.type === 'exponential') {
+        return evaluateExponential(parameters, value);
+    } else if (parameters.type === 'interval') {
+        return evaluateInterval(parameters, value);
+    } else if (parameters.type === 'categorical') {
+        return evaluateCategorical(parameters, value);
+    } else {
+        assert(false, 'Invalid function type "' + parameters.type + '"');
+    }
 }
 
-function interpolateArray(a, b, t) {
-    var result = [];
-    for (var i = 0; i < a.length; i++) {
-        result[i] = interpolateNumber(a[i], b[i], t);
+function evaluateCategorical(parameters, value) {
+    for (var i = 0; i < parameters.domain.length; i++) {
+        if (value === parameters.domain[i]) {
+            return parameters.range[i];
+        }
     }
-    return result;
+    return parameters.range[0];
 }
 
-exports['interpolated'] = function(f) {
-    if (!f.stops) {
-        return constant(f);
+function evaluateInterval(parameters, value) {
+    assert(parameters.domain.length + 1 === parameters.range.length);
+    for (var i = 0; i < parameters.domain.length; i++) {
+        if (value < parameters.domain[i]) break;
     }
+    return parameters.range[i];
+}
 
-    var stops = f.stops,
-        base = f.base || 1,
-        interpolate = Array.isArray(stops[0][1]) ? interpolateArray : interpolateNumber;
+function evaluateExponential(parameters, value) {
+    var base = parameters.base !== undefined ? parameters.base : 1;
 
-    return function(z) {
-        // find the two stops which the current z is between
-        var low, high;
+    var i = 0;
+    while (true) {
+        if (i >= parameters.domain.length) break;
+        else if (value <= parameters.domain[i]) break;
+        else i++;
+    }
 
-        for (var i = 0; i < stops.length; i++) {
-            var stop = stops[i];
+    if (i === 0) {
+        return parameters.range[i];
 
-            if (stop[0] <= z) {
-                low = stop;
-            }
+    } else if (i === parameters.range.length) {
+        return parameters.range[i - 1];
 
-            if (stop[0] > z) {
-                high = stop;
-                break;
-            }
-        }
+    } else {
+        return interpolate(
+            value,
+            base,
+            parameters.domain[i - 1],
+            parameters.domain[i],
+            parameters.range[i - 1],
+            parameters.range[i]
+        );
+    }
+}
 
-        if (low && high) {
-            var zoomDiff = high[0] - low[0],
-                zoomProgress = z - low[0],
+function interpolate(input, base, inputLower, inputUpper, outputLower, outputUpper) {
+    if (outputLower.length) {
+        return interpolateArray(input, base, inputLower, inputUpper, outputLower, outputUpper);
+    } else {
+        return interpolateNumber(input, base, inputLower, inputUpper, outputLower, outputUpper);
+    }
+}
 
-                t = base === 1 ?
-                zoomProgress / zoomDiff :
-                (Math.pow(base, zoomProgress) - 1) / (Math.pow(base, zoomDiff) - 1);
+function interpolateNumber(input, base, inputLower, inputUpper, outputLower, outputUpper) {
+    var difference =  inputUpper - inputLower;
+    var progress = input - inputLower;
 
-            return interpolate(low[1], high[1], t);
+    var ratio;
+    if (base === 1) {
+        ratio = progress / difference;
+    } else {
+        ratio = (Math.pow(base, progress) - 1) / (Math.pow(base, difference) - 1);
+    }
 
-        } else if (low) {
-            return low[1];
+    return (outputLower * (1 - ratio)) + (outputUpper * ratio);
+}
 
-        } else if (high) {
-            return high[1];
-        }
-    };
-};
-
-exports['piecewise-constant'] = function(f) {
-    if (!f.stops) {
-        return constant(f);
+function interpolateArray(input, base, inputLower, inputUpper, outputLower, outputUpper) {
+    var output = [];
+    for (var i = 0; i < outputLower.length; i++) {
+        output[i] = interpolateNumber(input, base, inputLower, inputUpper, outputLower[i], outputUpper[i]);
     }
+    return output;
+}
 
-    var stops = f.stops;
+function is(value) {
+    return typeof value === 'object' && !Array.isArray(value);
+}
 
-    return function(z) {
-        for (var i = 0; i < stops.length; i++) {
-            if (stops[i][0] > z) {
-                return stops[i === 0 ? 0 : i - 1][1];
-            }
-        }
-
-        return stops[stops.length - 1][1];
+function assert(predicate, message) {
+    if (!predicate) {
+        throw new Error(message || 'Assertion failed');
     }
-};
+}

package.json

 {
   "name": "mapbox-gl-function",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Evaluate a Mapbox GL style function",
-  "dependencies": {},
   "devDependencies": {
+    "eslint": "^0.22.1",
+    "mapbox-gl-style-spec": "git+https://github.com/mapbox/mapbox-gl-style-spec.git#v8",
     "tape": "^3.5.0"
   },
   "scripts": {
-    "test": "tape test.js"
+    "test": "eslint index.js test/*.js && tape test/*.js"
   },
@@ -19,3 +20,35 @@ "engines": {
   },
-  "license": "ISC"
+  "license": "ISC",
+  "eslintConfig": {
+    "rules": {
+      "no-use-before-define": [
+        2,
+        "nofunc"
+      ],
+      "camelcase": 2,
+      "space-after-function-name": 2,
+      "space-in-parens": 2,
+      "space-before-blocks": 2,
+      "space-after-keywords": 2,
+      "comma-style": 2,
+      "no-lonely-if": 2,
+      "new-cap": 0,
+      "no-empty": 2,
+      "no-new": 2,
+      "no-multi-spaces": 0,
+      "space-in-brackets": 0,
+      "brace-style": 0,
+      "quotes": 0,
+      "no-underscore-dangle": 0,
+      "curly": 0,
+      "no-constant-condition": 0,
+      "no-native-reassign": 0,
+      "no-shadow": 0,
+      "key-spacing": 0
+    },
+    "env": {
+      "node": true,
+      "browser": true
+    }
+  }
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

New author

Supply chain risk

A new npm collaborator published a version of the package for the first time. New collaborators are usually benign additions to a project, but do indicate a change to the security surface area of a package.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Lines of code

453

increased by219.01%

Worsened metrics

Total package byte prevSize

18048

decreased by-36.1%

Dev dependency count

3

increased by200%

Number of package files

8

decreased by-50%

Number of medium supply chain risk alerts

2

increased byInfinity%

No dependency changes