phenomnomnominal

var getCSSSelector = function () {
    var path, node = this;
    while (node.length) {
        var realNode = node[0], name = realNode.localName;
        if (!name) break;
        name = name.toLowerCase();
        var parent = node.parent();

        var sameTagSiblings = parent.children(name);
        if (sameTagSiblings.length > 1) { 

phenomnomnominal

var esprima = require('esprima'); 
var esquery = require('esquery');
var ast = esprima.parse('function hello () { }');
var func = esquery(ast, 'FunctionDeclaration');
console.log(ast.body[0] === func); // false;

phenomnomnominal

if (navigator.getBattery) {
    navigator.getBattery().then((battery) => {
        if (battery && battery.level < 0.2) {
            let disableAnimations = document.createElement('style');
            disableAnimations.type = 'text/css';
            disableAnimations.innerHTML = `
                * {
                    transition-property: none !important;
                    animation: none !important;
                }

phenomnomnominal

var oldCreateElement = document.createElement;
document.createElement = function () {
    var tagName = arguments[0];
    var element = oldCreateElement.apply(document, arguments);
    if (tagName === 'script') {
        element.setAttribute('defer', '');
    }
    return element;
};

phenomnomnominal

// Test Utilities:
import { ast, expect } from './index';

// Under test:
import { Rule } from '../src/noTypeofBrowserGlobalRule';

describe('no-typeof-browser-global', () => {
    it('should fail when `typeof` is used to check for "document"', () => {
        const sourceFile = ast(`
            typeof document === 'undefined';

phenomnomnominal

// Dependencies:
import { tsquery } from '@phenomnomnominal/tsquery';
import { Fix, Replacement, RuleFailure, Rules } from 'tslint';
import { SourceFile } from 'typescript';

// Constants:
const FDESCRIBE_FIT_QUERY = 'CallExpression > Identifier[name=/^f(describe|it)$/]';

const FAILURE_MESSAGE = (filter: string) => `

phenomnomnominal

// Dependencies:
import { RuleFailure, Rules } from 'tslint';
import { SourceFile } from 'typescript';

export class Rule extends Rules.AbstractRule {
    public apply (sourceFile: SourceFile): Array<RuleFailure> {
        
    }
}

phenomnomnominal

// Dependencies:
import { RuleFailure, Rules } from 'tslint';
import { SourceFile } from 'typescript';

export class Rule extends Rules.AbstractRule {
    public apply (sourceFile: SourceFile): Array<RuleFailure> {
        return this.applyWithWalker(new MyCustomRuleWalker(sourceFile));
    }
}

phenomnomnominal

import { AbstractWalker } from 'tslint';
import { forEachChild, Node, SourceFile } from 'typescript';

class NoFDescribeOrFItWalker extends AbstractWalker {
    public walk (sourceFile: SourceFile) {
        const walkNode = (node: Node): void => {
            // ...
            // evaluate rule
            // ...
            return forEachChild(node, walkNode);

phenomnomnominal

import { AbstractWalker } from 'tslint';
import { forEachChild, Node, SourceFile, SyntaxKind } from 'typescript';

class NoFDescribeOrFItWalker extends AbstractWalker {
    public walk (sourceFile: SourceFile) {
        const walkNode = (node: Node): void => {
            if (node.kind === SyntaxKind.CallExpression) {
                if (node.expression.kind === SyntaxKind.Identifier) {
                    // possible rule match!
                }