slnodejs 6.1.2 → 6.1.10

package/tsOutputs/build-scanner/js_diff/guess-method-name.js

@@ -1,55 +1,55 @@
-function guessMethodName(node, anc) {
-    var actualName = node.id && node.id.name || node.key && node.key.name;
-    if (actualName && ((node.kind == "set") || (node.kind == "get"))) {
-        actualName = node.kind + " " + actualName;
-    }
-    var isAnonymous = !actualName;
-    var methodType = null;
-    var guessName = "(Anonymous)";
-    var property = "ObjectProperty";
-    if (isAnonymous) {
-        if (anc) {
-            switch (anc.type) {
-                case "VariableDeclarator":
-                    if (anc.id && anc.id.type == "Identifier") {
-                        guessName = anc.id.name;
-                    }
-                    break;
-                case "ObjectProperty":
-                case "ObjectMethod":
-                    if (anc.key && anc.key.type == "Identifier") {
-                        guessName = anc.key.name;
-                        methodType = "getterSetter";
-                    }
-                    break;
-                case "AssignmentExpression":
-                    if (anc.left && anc.left.type == "MemberExpression" && anc.left.property && anc.left.property.type == "Identifier") {
-                        guessName = anc.left.property.name;
-                    }
-                    else if (anc.left && anc.left.type == "Identifier") {
-                        guessName = anc.left.name;
-                    }
-                    break;
-                case "CallExpression":
-                    //This is an anonymous function passed to a function, nothing useful to add
-                    break;
-                case "MethodDefinition":
-                    if (anc.key && anc.key.type == "Identifier") {
-                        guessName = anc.key.name;
-                        methodType = "method";
-                    }
-                    break;
-                default:
-                    break;
-            }
-        }
-    }
-    return {
-        actualName: actualName,
-        name: actualName || guessName,
-        type: methodType,
-        isAnonymous: isAnonymous
-    };
-}
-module.exports.guessMethodName = guessMethodName;
+function guessMethodName(node, anc) {
+    var actualName = node.id && node.id.name || node.key && node.key.name;
+    if (actualName && ((node.kind == "set") || (node.kind == "get"))) {
+        actualName = node.kind + " " + actualName;
+    }
+    var isAnonymous = !actualName;
+    var methodType = null;
+    var guessName = "(Anonymous)";
+    var property = "ObjectProperty";
+    if (isAnonymous) {
+        if (anc) {
+            switch (anc.type) {
+                case "VariableDeclarator":
+                    if (anc.id && anc.id.type == "Identifier") {
+                        guessName = anc.id.name;
+                    }
+                    break;
+                case "ObjectProperty":
+                case "ObjectMethod":
+                    if (anc.key && anc.key.type == "Identifier") {
+                        guessName = anc.key.name;
+                        methodType = "getterSetter";
+                    }
+                    break;
+                case "AssignmentExpression":
+                    if (anc.left && anc.left.type == "MemberExpression" && anc.left.property && anc.left.property.type == "Identifier") {
+                        guessName = anc.left.property.name;
+                    }
+                    else if (anc.left && anc.left.type == "Identifier") {
+                        guessName = anc.left.name;
+                    }
+                    break;
+                case "CallExpression":
+                    //This is an anonymous function passed to a function, nothing useful to add
+                    break;
+                case "MethodDefinition":
+                    if (anc.key && anc.key.type == "Identifier") {
+                        guessName = anc.key.name;
+                        methodType = "method";
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    return {
+        actualName: actualName,
+        name: actualName || guessName,
+        type: methodType,
+        isAnonymous: isAnonymous
+    };
+}
+module.exports.guessMethodName = guessMethodName;
 //# sourceMappingURL=guess-method-name.js.map

package/tsOutputs/build-scanner/js_diff/method-signature.js

@@ -1,143 +1,143 @@
-var guessMethodLocation = require('./guess-method-location').guessMethodLocation;
-var guessMethodName = require('./guess-method-name').guessMethodName;
-var astUtils = require('sl-esprima-ast-utils');
-var md5 = require('md5');
-var babelGenerator = require("@babel/generator");
-var traverse = require('ast-traverse');
-var AstNodeTypes = require("./ast-node-types");
-var utils = require("../utils");
-var globalMethodIndexer = require("./globalMethodIndexer");
-/**
- * Crates method object from node recived from ast
- * @constructor
- */
-function MethodSignature(node, parentNode, nodeToParent, absolutePath, relativePath, logger) {
-    this.node = node;
-    this.parentNode = parentNode;
-    this.nodeToParent = nodeToParent;
-    this.logger = logger;
-    this.generatedData = new MethodData(absolutePath, relativePath);
-    this.srcData = new MethodData();
-    this.meta = {};
-    this.type = null;
-    this.shouldSkip = false;
-    this.hasSourceData = false;
-    this.techSpecificInfo = this.createTechSpecificInfoInterface();
-    this.idxInMapping = globalMethodIndexer.getCurrentIndex();
-}
-MethodSignature.prototype._createSignature = function () {
-    var location = guessMethodLocation(this.node, this.nodeToParent);
-    var nameObject = guessMethodName(this.node, this.parentNode);
-    this.type = nameObject.type;
-    this.generatedData.position = formatLocationToArray(location.start);
-    this.generatedData.endPosition = formatLocationToArray(this.node.loc.end);
-    this.generatedData.identifierPosition = this.getIdentifierPosition();
-    this.generatedData.hash = this.calculateHash();
-    this.generatedData.sigHash = this.calculateSigHash();
-    this.generatedData.displayName = nameObject.name;
-    this.meta.anonymous = nameObject.isAnonymous;
-    this.meta.identifierPosition = this.getIdentifierPosition();
-    this.techSpecificInfo.isAnonymous = nameObject.isAnonymous;
-    this.srcData = utils.cloneObject(this.generatedData, this.logger);
-};
-MethodSignature.prototype.calculateHash = function () {
-    var context = this;
-    var clonedNode = astUtils.clone(this.node);
-    // Visit node in pre order and calculate body hash.
-    traverse(clonedNode, {
-        pre: function (node) {
-            // If current node is the root node given return (we want to calculate the body hash only).
-            if (node == clonedNode)
-                return;
-            if (AstNodeTypes.isMethodNode(node)) {
-                context.emptyNode(node);
-            }
-        }
-    });
-    var generatedCode = this.generateCodeFromAST(clonedNode);
-    return md5(generatedCode);
-};
-MethodSignature.prototype.calculateSigHash = function () {
-    var context = this;
-    if (!this.node.params || this.node.params.length == 0) {
-        return "";
-    }
-    var paramsStr = this.node.params.map(function (param) {
-        return context.generateCodeFromAST(param);
-    }).join(',');
-    return md5(paramsStr);
-};
-MethodSignature.prototype.emptyNode = function (node) {
-    node.body = {
-        type: AstNodeTypes.BlockStatement,
-        body: []
-    };
-    node.params = [];
-    node.id = {
-        name: '_',
-        type: AstNodeTypes.Identifier
-    };
-};
-MethodSignature.prototype.generateCodeFromAST = function (node) {
-    return babelGenerator.default(node, {
-        comments: false
-    }, '').code;
-};
-MethodSignature.prototype.createTechSpecificInfoInterface = function () {
-    return {
-        isAsync: this.node.async || false,
-        isComputed: this.node.computed || false,
-        isExpression: this.node.expression || false,
-        isGenerator: this.node.generator || false,
-        kind: this.node.kind,
-        isStatic: this.node.static || false,
-        isDecorated: this.node.decorators && this.node.decorators.length > 0
-    };
-};
-MethodSignature.prototype.createUniqueId = function () {
-    var relevantData = this.hasSourceData ? this.srcData : this.generatedData;
-    return [relevantData.relativeFilename, relevantData.position.join(',')].join('@');
-};
-MethodSignature.prototype.createUniqueIdKeyForSlMapping = function () {
-    return [this.generatedData.absoluteFilename, this.generatedData.position.join(",")].join('@');
-};
-MethodSignature.prototype.createDTO = function () {
-    return {
-        meta: this.meta,
-        techSpecificInfo: this.techSpecificInfo,
-        type: this.type,
-        srcData: this.srcData,
-        generatedData: this.generatedData,
-        uniqueId: this.createUniqueId(),
-        idxInMapping: this.idxInMapping,
-        uniqueIdKey: this.createUniqueIdKeyForSlMapping()
-    };
-};
-MethodSignature.create = function (node, parentNode, nodeToParent, absolutePath, relativePath, logger) {
-    var signature = new this(node, parentNode, nodeToParent, absolutePath, relativePath, logger);
-    signature._createSignature();
-    return signature;
-};
-function formatLocationToArray(loc) {
-    return [loc.line, loc.column];
-}
-function MethodData(absolutePath, relativePath) {
-    this.position = null;
-    this.endPosition = null;
-    this.displayName = null;
-    this.hash = null;
-    this.sigHash = null;
-    this.relativeFilename = relativePath;
-    this.absoluteFilename = absolutePath;
-    this.identifierPosition = null;
-}
-MethodSignature.prototype.getIdentifierPosition = function () {
-    var identifier = this.node.id || this.node.key;
-    var position = identifier && (identifier.position || identifier.loc);
-    if (identifier && position && position.end) {
-        return formatLocationToArray(position.end);
-    }
-    return [];
-};
-module.exports = MethodSignature;
+var guessMethodLocation = require('./guess-method-location').guessMethodLocation;
+var guessMethodName = require('./guess-method-name').guessMethodName;
+var astUtils = require('sl-esprima-ast-utils');
+var md5 = require('md5');
+var babelGenerator = require("@babel/generator");
+var traverse = require('ast-traverse');
+var AstNodeTypes = require("./ast-node-types");
+var utils = require("../utils");
+var globalMethodIndexer = require("./globalMethodIndexer");
+/**
+ * Crates method object from node recived from ast
+ * @constructor
+ */
+function MethodSignature(node, parentNode, nodeToParent, absolutePath, relativePath, logger) {
+    this.node = node;
+    this.parentNode = parentNode;
+    this.nodeToParent = nodeToParent;
+    this.logger = logger;
+    this.generatedData = new MethodData(absolutePath, relativePath);
+    this.srcData = new MethodData();
+    this.meta = {};
+    this.type = null;
+    this.shouldSkip = false;
+    this.hasSourceData = false;
+    this.techSpecificInfo = this.createTechSpecificInfoInterface();
+    this.idxInMapping = globalMethodIndexer.getCurrentIndex();
+}
+MethodSignature.prototype._createSignature = function () {
+    var location = guessMethodLocation(this.node, this.nodeToParent);
+    var nameObject = guessMethodName(this.node, this.parentNode);
+    this.type = nameObject.type;
+    this.generatedData.position = formatLocationToArray(location.start);
+    this.generatedData.endPosition = formatLocationToArray(this.node.loc.end);
+    this.generatedData.identifierPosition = this.getIdentifierPosition();
+    this.generatedData.hash = this.calculateHash();
+    this.generatedData.sigHash = this.calculateSigHash();
+    this.generatedData.displayName = nameObject.name;
+    this.meta.anonymous = nameObject.isAnonymous;
+    this.meta.identifierPosition = this.getIdentifierPosition();
+    this.techSpecificInfo.isAnonymous = nameObject.isAnonymous;
+    this.srcData = utils.cloneObject(this.generatedData, this.logger);
+};
+MethodSignature.prototype.calculateHash = function () {
+    var context = this;
+    var clonedNode = astUtils.clone(this.node);
+    // Visit node in pre order and calculate body hash.
+    traverse(clonedNode, {
+        pre: function (node) {
+            // If current node is the root node given return (we want to calculate the body hash only).
+            if (node == clonedNode)
+                return;
+            if (AstNodeTypes.isMethodNode(node)) {
+                context.emptyNode(node);
+            }
+        }
+    });
+    var generatedCode = this.generateCodeFromAST(clonedNode);
+    return md5(generatedCode);
+};
+MethodSignature.prototype.calculateSigHash = function () {
+    var context = this;
+    if (!this.node.params || this.node.params.length == 0) {
+        return "";
+    }
+    var paramsStr = this.node.params.map(function (param) {
+        return context.generateCodeFromAST(param);
+    }).join(',');
+    return md5(paramsStr);
+};
+MethodSignature.prototype.emptyNode = function (node) {
+    node.body = {
+        type: AstNodeTypes.BlockStatement,
+        body: []
+    };
+    node.params = [];
+    node.id = {
+        name: '_',
+        type: AstNodeTypes.Identifier
+    };
+};
+MethodSignature.prototype.generateCodeFromAST = function (node) {
+    return babelGenerator.default(node, {
+        comments: false
+    }, '').code;
+};
+MethodSignature.prototype.createTechSpecificInfoInterface = function () {
+    return {
+        isAsync: this.node.async || false,
+        isComputed: this.node.computed || false,
+        isExpression: this.node.expression || false,
+        isGenerator: this.node.generator || false,
+        kind: this.node.kind,
+        isStatic: this.node.static || false,
+        isDecorated: this.node.decorators && this.node.decorators.length > 0
+    };
+};
+MethodSignature.prototype.createUniqueId = function () {
+    var relevantData = this.hasSourceData ? this.srcData : this.generatedData;
+    return [relevantData.relativeFilename, relevantData.position.join(',')].join('@');
+};
+MethodSignature.prototype.createUniqueIdKeyForSlMapping = function () {
+    return [this.generatedData.absoluteFilename, this.generatedData.position.join(",")].join('@');
+};
+MethodSignature.prototype.createDTO = function () {
+    return {
+        meta: this.meta,
+        techSpecificInfo: this.techSpecificInfo,
+        type: this.type,
+        srcData: this.srcData,
+        generatedData: this.generatedData,
+        uniqueId: this.createUniqueId(),
+        idxInMapping: this.idxInMapping,
+        uniqueIdKey: this.createUniqueIdKeyForSlMapping()
+    };
+};
+MethodSignature.create = function (node, parentNode, nodeToParent, absolutePath, relativePath, logger) {
+    var signature = new this(node, parentNode, nodeToParent, absolutePath, relativePath, logger);
+    signature._createSignature();
+    return signature;
+};
+function formatLocationToArray(loc) {
+    return [loc.line, loc.column];
+}
+function MethodData(absolutePath, relativePath) {
+    this.position = null;
+    this.endPosition = null;
+    this.displayName = null;
+    this.hash = null;
+    this.sigHash = null;
+    this.relativeFilename = relativePath;
+    this.absoluteFilename = absolutePath;
+    this.identifierPosition = null;
+}
+MethodSignature.prototype.getIdentifierPosition = function () {
+    var identifier = this.node.id || this.node.key;
+    var position = identifier && (identifier.position || identifier.loc);
+    if (identifier && position && position.end) {
+        return formatLocationToArray(position.end);
+    }
+    return [];
+};
+module.exports = MethodSignature;
 //# sourceMappingURL=method-signature.js.map