@microsoft/sp-tslint-rules 1.20.2 → 1.21.0-beta.2

package/lib-commonjs/importRequiresChunkNameRule.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Rule", {
+    enumerable: true,
+    get: function() {
+        return Rule;
+    }
+});
+const _tsutils = require("tsutils");
+const _typescript = /*#__PURE__*/ _interop_require_wildcard(require("typescript"));
+const _tslint = /*#__PURE__*/ _interop_require_wildcard(require("tslint"));
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+/**
+ * Matches parts of the webpack import(...) meta-comment that look like these examples:
+ *  - propertyName:'value'
+ *  - propertyName: 'value'
+ *  - propertyName:"value"
+ *  - propertyName: "value"
+ *  - propertyName :'value'
+ *  - propertyName : 'value'
+ *  - propertyName :"value"
+ *  - propertyName : "value"
+ */ const COMMENT_PART_REGEX = /^([A-Za-z]+)\s*:\s*('[^']+'|"[^"]+")$/;
+var _Lint_Rules_AbstractRule;
+class Rule extends (_Lint_Rules_AbstractRule = _tslint.Rules.AbstractRule) {
+    apply(sourceFile) {
+        return this.applyWithFunction(sourceFile, (ctx)=>{
+            const childCallback = (node)=>{
+                if ((0, _tsutils.isCallExpression)(node) && node.expression.kind === _typescript.SyntaxKind.ImportKeyword && node.getChildCount() >= 4 // 4+ children: keyword, openParen, args..., closeParen
+                ) {
+                    // In an import(...) expression
+                    const comments = [];
+                    (0, _tsutils.forEachComment)(node, (text, comment)=>{
+                        comments.push(text.substring(comment.pos, comment.end));
+                    });
+                    let webpackChunkNameTokensFound = 0;
+                    for (const rawComment of comments){
+                        let comment = rawComment.trim();
+                        if (comment.indexOf('//') === 0) {
+                            comment = comment.substr(2);
+                        } else if (comment.indexOf('/*') === 0 && comment.indexOf('*/') === comment.length - 2) {
+                            comment = comment.substring(2, comment.length - 2);
+                        }
+                        const commentParts = comment.split(',');
+                        for (let commentPart of commentParts){
+                            commentPart = commentPart.trim();
+                            const commentRegexResult = commentPart.match(COMMENT_PART_REGEX);
+                            if (commentRegexResult && commentRegexResult[1] === 'webpackChunkName') {
+                                webpackChunkNameTokensFound++;
+                            }
+                        }
+                    }
+                    if (webpackChunkNameTokensFound === 0) {
+                        ctx.addFailureAtNode(node.expression, 'Calls to "import" must include a /* webpackChunkName: \'name\' */ comment');
+                    } else if (webpackChunkNameTokensFound !== 1) {
+                        ctx.addFailureAtNode(node.expression, 'Calls to "import" must include only one /* webpackChunkName: \'name\' */ comment');
+                    }
+                }
+                return _typescript.forEachChild(node, childCallback);
+            };
+            return _typescript.forEachChild(ctx.sourceFile, childCallback);
+        });
+    }
+}
+_define_property(Rule, "metadata", {
+    ruleName: 'import-requires-chunk-name',
+    description: 'Requires that calls to import(...) for code splitting include a webpack chunk name',
+    rationale: 'Unnamed chunks are difficult to manage.',
+    optionsDescription: 'No options available.',
+    options: {},
+    type: 'functionality',
+    typescriptOnly: false
+});
+
+//#sourceMappingUrl=./importRequiresChunkNameRule.js.map

package/lib-commonjs/index.js

@@ -0,0 +1,9 @@
+/**
+ * SharePoint Framework tslint rules.
+ * @remarks
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//#sourceMappingUrl=./index.js.map

package/lib-commonjs/noAsyncAwaitRule.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Rule", {
+    enumerable: true,
+    get: function() {
+        return Rule;
+    }
+});
+const _tsutils = require("tsutils");
+const _typescript = /*#__PURE__*/ _interop_require_wildcard(require("typescript"));
+const _tslint = /*#__PURE__*/ _interop_require_wildcard(require("tslint"));
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _Lint_Rules_AbstractRule;
+class Rule extends (_Lint_Rules_AbstractRule = _tslint.Rules.AbstractRule) {
+    apply(source) {
+        return this.applyWithFunction(source, noAsyncAwait);
+    }
+}
+_define_property(Rule, "metadata", {
+    ruleName: 'no-async-await',
+    description: 'Warn when using async/await functions.',
+    rationale: 'async/await has overhead when emitting ES5 JavaScript',
+    optionsDescription: 'No options available.',
+    options: undefined,
+    type: 'functionality',
+    typescriptOnly: false
+});
+function noAsyncAwait(context, node) {
+    if (!node) {
+        _typescript.forEachChild(context.sourceFile, (n)=>noAsyncAwait(context, n));
+    } else {
+        if ((0, _tsutils.isArrowFunction)(node) || (0, _tsutils.isFunctionDeclaration)(node) || (0, _tsutils.isFunctionExpression)(node) || (0, _tsutils.isMethodDeclaration)(node)) {
+            checkAndReportIfAsync(context, node);
+        }
+        _typescript.forEachChild(node, (n)=>noAsyncAwait(context, n));
+    }
+}
+function checkAndReportIfAsync(context, node) {
+    if (node.body === undefined && node.type !== undefined) {
+        return;
+    }
+    if (node.modifiers !== undefined && node.modifiers.find((modifier)=>modifier.kind === _typescript.SyntaxKind.AsyncKeyword)) {
+        context.addFailureAtNode(node, 'async/await usage is not allowed');
+    }
+}
+
+//#sourceMappingUrl=./noAsyncAwaitRule.js.map

package/lib-commonjs/noRequireEnsureRule.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Rule", {
+    enumerable: true,
+    get: function() {
+        return Rule;
+    }
+});
+const _tsutils = require("tsutils");
+const _typescript = /*#__PURE__*/ _interop_require_wildcard(require("typescript"));
+const _tslint = /*#__PURE__*/ _interop_require_wildcard(require("tslint"));
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _Lint_Rules_AbstractRule;
+class Rule extends (_Lint_Rules_AbstractRule = _tslint.Rules.AbstractRule) {
+    apply(sourceFile) {
+        return this.applyWithFunction(sourceFile, (ctx)=>{
+            const childCallback = (node)=>{
+                if ((0, _tsutils.isCallExpression)(node) && (0, _tsutils.isPropertyAccessExpression)(node.expression) && (0, _tsutils.isIdentifier)(node.expression.expression) && node.expression.expression.text === 'require' && node.expression.getChildCount() === 3) {
+                    const lastChild = node.expression.getChildAt(2);
+                    if ((0, _tsutils.isIdentifier)(lastChild) && lastChild.text === 'ensure') {
+                        ctx.addFailureAtNode(node.expression, "Calls to 'require.ensure' are not allowed. Use 'import' instead.");
+                    }
+                }
+                return _typescript.forEachChild(node, childCallback);
+            };
+            return _typescript.forEachChild(ctx.sourceFile, childCallback);
+        });
+    }
+}
+_define_property(Rule, "metadata", {
+    ruleName: 'no-require-ensure',
+    description: 'Warns about the use of the require.ensure function.',
+    rationale: '`require.ensure` is outdated. Use `import(...)` instead.',
+    optionsDescription: 'No options available.',
+    options: {},
+    type: 'functionality',
+    typescriptOnly: false
+});
+
+//#sourceMappingUrl=./noRequireEnsureRule.js.map

package/lib-commonjs/pairReactDomRenderUnmountRule.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Rule", {
+    enumerable: true,
+    get: function() {
+        return Rule;
+    }
+});
+const _tsutils = /*#__PURE__*/ _interop_require_wildcard(require("tsutils"));
+const _typescript = /*#__PURE__*/ _interop_require_wildcard(require("typescript"));
+const _tslint = /*#__PURE__*/ _interop_require_wildcard(require("tslint"));
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _Lint_Rules_AbstractRule;
+class Rule extends (_Lint_Rules_AbstractRule = _tslint.Rules.AbstractRule) {
+    apply(sourceFile) {
+        return this.applyWithFunction(sourceFile, this._walk.bind(this));
+    }
+    _walk(ctx) {
+        const renderCalls = [];
+        const unmountCalls = [];
+        // Do not convert `callback` to a function. It references `this` keyword inside it.
+        const callback = (node)=>{
+            const reactDOMImportNamespaceName = this._getReactDOMImportNamespaceName(node);
+            if (reactDOMImportNamespaceName) {
+                this._reactDOMImportNamespaceName = reactDOMImportNamespaceName;
+                return;
+            }
+            const isRenderCallExpression = this._isReactDOMCallExpression(node, 'render');
+            if (isRenderCallExpression) {
+                renderCalls.push(node);
+                return;
+            }
+            const isUnmountCallExpression = this._isReactDOMCallExpression(node, 'unmountComponentAtNode');
+            if (isUnmountCallExpression) {
+                unmountCalls.push(node);
+                return;
+            }
+            _typescript.forEachChild(node, callback);
+        };
+        _typescript.forEachChild(ctx.sourceFile, callback);
+        // Verify the count of render calls and unmount calls are the same in the file.
+        if (renderCalls.length !== unmountCalls.length) {
+            renderCalls.concat(unmountCalls).forEach((renderCallExpression)=>{
+                ctx.addFailureAtNode(renderCallExpression, 'Unmatched calls between `ReactDOM.render` and `ReactDOM.unmountComponentAtNode`.');
+            });
+        }
+    }
+    _getReactDOMImportNamespaceName(node) {
+        if (// import * as ReactDOM from 'react-dom'
+        _tsutils.isImportDeclaration(node) && // * as ReactDOM
+        node.importClause && _tsutils.isImportClause(node.importClause) && // ReactDOM
+        node.importClause.namedBindings && _tsutils.isNamespaceImport(node.importClause.namedBindings) && // 'react-dom'
+        _tsutils.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === 'react-dom') {
+            return node.importClause.namedBindings.name.text;
+        } else {
+            return undefined;
+        }
+    }
+    _isReactDOMCallExpression(node, methodName) {
+        return(// ReactDOM.method(param1, param2)
+        _tsutils.isCallExpression(node) && // ReactDOM.method
+        _tsutils.isPropertyAccessExpression(node.expression) && // ReactDOM
+        _tsutils.isIdentifier(node.expression.expression) && node.expression.expression.text === this._reactDOMImportNamespaceName && // method
+        _tsutils.isIdentifier(node.expression.name) && node.expression.name.text === methodName);
+    }
+    constructor(...args){
+        super(...args);
+        _define_property(this, "_reactDOMImportNamespaceName", void 0);
+    }
+}
+_define_property(Rule, "metadata", {
+    ruleName: 'pair-react-dom-render-unmount',
+    description: 'Pair ReactDOM render and unmount calls in one file.' + ' If a ReactDOM render tree is not unmounted when disposed, it will cause a memory leak.',
+    rationale: 'Pair the render and unmount calls to avoid memory leak.',
+    optionsDescription: 'No options available.',
+    options: {},
+    type: 'maintainability',
+    typescriptOnly: false
+});
+
+//#sourceMappingUrl=./pairReactDomRenderUnmountRule.js.map

package/lib-commonjs/scripts/runTslintTests.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "runAsync", {
+    enumerable: true,
+    get: function() {
+        return runAsync;
+    }
+});
+const _tslint = /*#__PURE__*/ _interop_require_wildcard(require("tslint"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+async function runAsync(options) {
+    const { heftTaskSession: { logger } } = options;
+    const testResults = _tslint.Test.runTests([
+        'test/**/tslint.json'
+    ], 'lib-commonjs');
+    const isSuccess = _tslint.Test.consoleTestResultsHandler(testResults, {
+        log: logger.terminal.writeLine.bind(logger.terminal),
+        error: logger.terminal.writeErrorLine.bind(logger.terminal)
+    });
+    if (!isSuccess) {
+        const e = new Error('TSLint tests failed.');
+        logger.emitError(e);
+        throw e;
+    }
+}
+
+//#sourceMappingUrl=./runTslintTests.js.map

package/lib-commonjs/validKillSwitchGuidRule.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Rule", {
+    enumerable: true,
+    get: function() {
+        return Rule;
+    }
+});
+const _tslint = /*#__PURE__*/ _interop_require_wildcard(require("tslint"));
+const _tsutils = require("tsutils");
+const _typescript = /*#__PURE__*/ _interop_require_wildcard(require("typescript"));
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _Lint_Rules_AbstractRule;
+class Rule extends (_Lint_Rules_AbstractRule = _tslint.Rules.AbstractRule) {
+    apply(source) {
+        return this.applyWithFunction(source, validKillSwitchGuid);
+    }
+}
+_define_property(Rule, "metadata", {
+    ruleName: 'valid-kill-switch-guid',
+    description: 'Warn if _SPKillSwitch.isActivated is being called with an incorrect argument',
+    rationale: 'Compile time type safety',
+    optionsDescription: 'No options available.',
+    options: undefined,
+    type: 'functionality',
+    typescriptOnly: false
+});
+function validKillSwitchGuid(context, node) {
+    if (!node) {
+        _typescript.forEachChild(context.sourceFile, (n)=>validKillSwitchGuid(context, n));
+    } else {
+        if ((0, _tsutils.isCallExpression)(node) && isSPKillSwitch(node) && !isValidGuid(node.arguments[0].getText())) {
+            context.addFailureAtNode(node, '_SPKillSwitch.isActivated argument must be a valid, lower-case GUID');
+        }
+        _typescript.forEachChild(node, (n)=>validKillSwitchGuid(context, n));
+    }
+}
+function isSPKillSwitch(node) {
+    return (0, _tsutils.isPropertyAccessExpression)(node.expression) && node.expression.name.getText() === 'isActivated' && (0, _tsutils.isIdentifier)(node.expression.expression) && (node.expression.expression.getText() === '_SPKillSwitch' || node.expression.expression.getText() === 'SPKillSwitch') && node.arguments.length === 1;
+}
+function isValidGuid(guidString) {
+    return /^'[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}'$/.test(guidString);
+}
+
+//#sourceMappingUrl=./validKillSwitchGuidRule.js.map

package/lib-dts/scripts/runTslintTests.d.ts

@@ -0,0 +1,3 @@
+import type { IRunScriptOptions } from '@rushstack/heft';
+export declare function runAsync(options: IRunScriptOptions): Promise<void>;
+//# sourceMappingURL=runTslintTests.d.ts.map