Initial commit

node_modules/eslint-plugin-office-addins/test/rules/call-sync-after-load.test.ts

@@ -0,0 +1,194 @@
+import { RuleTester } from "@typescript-eslint/rule-tester";
+import rule from "../../src/rules/call-sync-after-load";
+
+const ruleTester = new RuleTester();
+
+ruleTester.run("call-sync-after-load", rule, {
+  valid: [
+    {
+      code: `
+        var property = worksheet.getItem("sheet");
+        property.load("values");
+        await context.sync();
+        console.log(property.values);`,
+    },
+    {
+      code: `
+        var fakeGet = worksheet.notAGetFunction("props");
+        await context.sync();
+        fakeGet.load("props");
+        console.log(fakeGet.props);`,
+    },
+    {
+      code: `
+        var fakeGet = worksheet.notAGetFunction("props");
+        await context.sync();
+        property.load("props");
+        console.log(property.props);`,
+    },
+    {
+      code: `
+        var table = worksheet.getTables();
+        return context.sync().then(function () {
+          table.delete();
+        });`,
+    },
+    {
+      code: `
+        var range = worksheet.getSelectedRange();
+        range.getCell(0,0);`,
+    },
+    {
+      code: `
+			  var range = worksheet.getSelectedRange();
+			  range.load("font/fill/color, address");
+			  await context.sync();
+			  console.log(range.font.fill.color);
+			  console.log(range.address);`,
+    },
+    {
+      code: `
+        var range = worksheet.getSelectedRange();
+        range.load("*");
+        await context.sync();
+        console.log(range.address);`,
+    },
+    {
+      code: `
+        var range = worksheet.getSelectedRange();
+        range.load();
+        await context.sync();
+        console.log(range.address);`,
+    },
+    {
+      code: `
+        var property = worksheet.getItem("sheet");
+        context.load(property, "values");
+        await context.sync();
+        console.log(property.values);`,
+    },
+    {
+      code: `
+        var property = worksheet.getItem("sheet");
+        context.load(property);
+        await context.sync();
+        console.log(property.values);`,
+    },
+  ],
+  invalid: [
+    {
+      code: `
+        var property = worksheet.getItem("sheet");
+        await context.sync();
+        property.load("values");
+        console.log(property.values);`,
+      errors: [
+        {
+          messageId: "callSyncAfterLoad",
+          data: { name: "property", loadValue: "values" },
+        },
+      ],
+    },
+    {
+      code: `
+        var property = worksheet.getItem("sheet");
+        property.load("values");
+        await context.sync();
+        console.log(property.values);
+        property.load("length");
+        console.log(property.length);`,
+      errors: [
+        {
+          messageId: "callSyncAfterLoad",
+          data: { name: "property", loadValue: "length" },
+        },
+      ],
+    },
+    {
+      code: `
+        var range = worksheet.getSelectedRange();
+        range.load(["font/fill/color", "address"]);
+        console.log(range.font.fill.color);`,
+      errors: [
+        {
+          messageId: "callSyncAfterLoad",
+          data: { name: "range", loadValue: "font/fill/color" },
+        },
+      ],
+    },
+    {
+      code: `
+        var range = worksheet.getSelectedRange();
+        range.load("*");
+        console.log(range.address);`,
+      errors: [
+        {
+          messageId: "callSyncAfterLoad",
+          data: { name: "range", loadValue: "address" },
+        },
+      ],
+    },
+    {
+      code: `
+        var range = worksheet.getSelectedRange();
+        range.load();
+        console.log(range.address);`,
+      errors: [
+        {
+          messageId: "callSyncAfterLoad",
+          data: { name: "range", loadValue: "address" },
+        },
+      ],
+    },
+    {
+      code: `
+        var property = worksheet.getItem("sheet");
+        await context.sync();
+        context.load(property, "values");
+        console.log(property.values);`,
+      errors: [
+        {
+          messageId: "callSyncAfterLoad",
+          data: { name: "property", loadValue: "values" },
+        },
+      ],
+    },
+    {
+      code: `
+        var property = worksheet.getItem("sheet");
+        context.load(property, "values");
+        console.log(property.values);`,
+      errors: [
+        {
+          messageId: "callSyncAfterLoad",
+          data: { name: "property", loadValue: "values" },
+        },
+      ],
+    },
+    {
+      code: `
+        var property = worksheet.getItem("sheet");
+        await context.sync();
+        context.load(property);
+        console.log(property.values);`,
+      errors: [
+        {
+          messageId: "callSyncAfterLoad",
+          data: { name: "property", loadValue: "values" },
+        },
+      ],
+    },
+    {
+      code: `
+        var property = worksheet.getItem("sheet");
+        context.load(property);
+        console.log(property.values);`,
+      errors: [
+        {
+          messageId: "callSyncAfterLoad",
+          data: { name: "property", loadValue: "values" },
+        },
+      ],
+    },
+  ],
+});

node_modules/eslint-plugin-office-addins/test/rules/call-sync-before-read.test.ts

@@ -0,0 +1,185 @@
+import { RuleTester } from "@typescript-eslint/rule-tester";
+import rule from "../../src/rules/call-sync-before-read";
+
+const ruleTester = new RuleTester();
+
+ruleTester.run("call-sync-before-read", rule, {
+  valid: [
+    {
+      code: `
+      Excel.run(function (context) {
+        var selectedRange = context.workbook.getSelectedRange();
+        selectedRange.load('address');
+        await context.sync()
+        console.log('The selected range is: ' + selectedRange.address);
+      });`,
+    },
+    {
+      code: `
+      Excel.run(function (context) {
+        var selectedRange;
+        selectedRange = context.workbook.getSelectedRange();
+        selectedRange.load('address');
+        await context.sync()
+        console.log('The selected range is: ' + selectedRange.address);
+      });`,
+    },
+    {
+      code: `
+      Excel.run(function (context) {
+        var selectedRange = context.workbook.getSelectedRange();
+        selectedRange.load('address');
+        return context.sync()
+          .then(function () {
+            console.log('The selected range is: ' + selectedRange.address);
+        });
+      })`,
+    },
+    {
+      code: `
+      Excel.run(function (context) {
+        var dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+        await context.sync();
+        if (dataSheet.isNullObject) {
+          dataSheet.position = 1;
+        }
+      })`,
+    },
+    {
+      code: `
+      Excel.run(function (context) {
+        var dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+        if (true) {
+          await context.sync();
+          dataSheet.position = 1;
+        }
+      })`,
+    },
+    {
+      code: `
+      Excel.run(function (context) {
+        var dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+        if (true) {
+          dataSheet.position = 1;  // Write is OK
+        }
+        await context.sync();
+      });`,
+    },
+    {
+      code: `
+      var range = context.workbook.worksheets.getItem(sheetName).getRange(rangeAddress);
+      range.format.fill.color = "yellow";`,
+    },
+    {
+      code: `
+      var range = context.workbook.worksheets.getItem(sheetName).getRange(rangeAddress);
+      range.format.font.load('color');`,
+    },
+    {
+      code: `
+        var table = worksheet.getTables();
+        return context.sync().then(function () {
+          table.delete();
+        });`,
+    },
+    {
+      code: `
+        var range = worksheet.getSelectedRange();
+        range.getCell(0,0);`,
+    },
+    {
+      code: `
+        var range = worksheet.getSelectedRange();
+        range.load("font");
+        context.sync();
+        range.font.getColor();`,
+    },
+    {
+      code: `
+        await Excel.run(async (context) => {
+        const sheet = context.workbook.worksheets.getActiveWorksheet();
+        let data: string[][] = [["one"], ["two"]];
+  
+        const rangeAddress = data.length;
+        const range = sheet.getRange(rangeAddress);
+        range.values = data;
+        range.format.autofitColumns();
+  
+        return context.sync();
+      });`,
+    },
+  ],
+  invalid: [
+    {
+      code: `
+      Excel.run(function (context) {
+        var selectedRange = context.workbook.getSelectedRange();
+        selectedRange.load('address');
+        console.log('The selected range is: ' + selectedRange.address);
+      });`,
+      errors: [{ messageId: "callSync", data: { name: "selectedRange" } }],
+    },
+    {
+      code: `
+      Excel.run(function (context) {
+        var selectedRange = context.workbook.getSelectedRange();
+        selectedRange.load('address');
+        console.log('The selected range is: ' + selectedRange.address);
+        await context.sync();
+      });`,
+      errors: [{ messageId: "callSync", data: { name: "selectedRange" } }],
+    },
+    {
+      code: `
+      Excel.run(function (context) {
+        var selectedRange = context.workbook.getSelectedRange();
+        var selectedRange2 = context.workbook.getSelectedRange();
+        selectedRange.load('address');
+        selectedRange2.load('address');
+        console.log('The selected range is: ' + selectedRange.address);
+        console.log('This should be the same: ' + selectedRange2.address);
+      });`,
+      errors: [
+        { messageId: "callSync", data: { name: "selectedRange" } },
+        { messageId: "callSync", data: { name: "selectedRange2" } },
+      ],
+    },
+    {
+      code: `
+      Excel.run(function (context) {
+        var dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+        if (dataSheet.isNullObject) {
+          dataSheet.position = 1;
+        }
+      });`,
+      errors: [{ messageId: "callSync", data: { name: "dataSheet" } }],
+    },
+    {
+      code: `
+      Excel.run(function (context) {
+        var dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+        if (true) {
+          var pos = dataSheet.position;
+        }
+        await context.sync();
+      });`,
+      errors: [{ messageId: "callSync", data: { name: "dataSheet" } }],
+    },
+    {
+      code: `
+      var range = context.workbook.worksheets.getItem(sheetName).getRange(rangeAddress);
+      range.format.fill.color == "yellow";`,
+      errors: [{ messageId: "callSync", data: { name: "range" } }],
+    },
+    {
+      code: `
+      var range = context.workbook.worksheets.getItem(sheetName).getRange(rangeAddress);
+      var value = range.format.fill.color;
+      value = range.format.fill.color;`,
+      errors: [
+        { messageId: "callSync", data: { name: "range" } },
+        { messageId: "callSync", data: { name: "range" } },
+      ],
+    },
+  ],
+});

node_modules/eslint-plugin-office-addins/test/rules/load-object-before-read.test.ts

@@ -0,0 +1,333 @@
+import { RuleTester } from "@typescript-eslint/rule-tester";
+import rule from "../../src/rules/load-object-before-read";
+
+const ruleTester = new RuleTester();
+
+ruleTester.run("load-object-before-read", rule, {
+  valid: [
+    {
+      code: `
+        var sheetName = 'Sheet1';
+        var rangeAddress = 'A1:B2';
+        var myRange = context.workbook.worksheets.getItem(sheetName).getRange(rangeAddress);  
+        myRange.load('address');
+        context.sync()
+          .then(function () {
+            console.log (myRange.address);   // ok
+          });`,
+    },
+    {
+      code: `
+        var property = worksheet.getItem("sheet");
+        property.load('G2');
+        var variableName = property.G2;`,
+    },
+    {
+      code: `
+        var selectedRange = context.workbook.getSelectedRange();
+        selectedRange.load('values');
+        if(selectedRange.values === [2]){}`,
+    },
+    {
+      code: `
+        var selectedRange;
+        var selectedRange = context.workbook.getSelectedRange();
+        selectedRange.load('values');
+        console.log(selectedRange.values);`,
+    },
+    {
+      code: `
+        var myRange = context.workbook.worksheets.getSelectedRange();
+        myRange = context.workbook.worksheets.getItem(sheetName).getRange(rangeAddress);
+        myRange.load('values');
+        console.log(myRange.values);`,
+    },
+    {
+      code: `
+        var myRange = context.workbook.worksheets.getSelectedRange();
+        myRange.load('values');
+        myRange.load('address');
+        console.log(myRange.address);
+        console.log(myRange.values);`,
+    },
+    {
+      code: `
+        var myRange = context.thisIsNotAGetFunction();
+        myRange.load('values')
+        var test = myRange.values;
+        var myRange = context.workbook.worksheets.getSelectedRange();`,
+    },
+    {
+      code: `
+        var myRange = context.workbook.worksheets.getSelectedRange();
+        myRange = context.notAGetFunction;
+        myRange.load('values');
+        var test = myRange.values;`,
+    },
+    {
+      code: `
+        var myRange = context.workbook.worksheets.getSelectedRange();
+        myRange = context.notAGetFunction;
+        var test = myRange.values;`,
+    },
+    {
+      code: `
+        var range = worksheet.getRange("A1");
+        range.format.fill.color = "red";
+        range.numberFormat = "0.00%";
+        range.values = [[1]];`,
+    },
+    {
+      code: `
+        var range = worksheet.getRange("A1");
+        range.load("format/fill/size");
+        console.log(range.format.fill.size);`,
+    },
+    {
+      code: `
+        var table = worksheet.getTables();
+        return context.sync().then(function () {
+          table.delete();
+        });`,
+    },
+    {
+      code: `
+        var range = worksheet.getSelectedRange();
+        range.getCell(0,0);`,
+    },
+    {
+      code: `
+			  var range = worksheet.getSelectedRange();
+			  range.load(["font/fill/color", "address"]);
+			  await context.sync();
+			  console.log(range.font.fill.color);
+			  console.log(range.address);`,
+    },
+    {
+      code: `
+        var range = worksheet.getSelectedRange();
+        range.load("*");
+        await context.sync();
+        console.log(range.address);
+        console.log(range.font);`,
+    },
+    {
+      code: `
+        var range = worksheet.getSelectedRange();
+        range.load();
+        await context.sync();
+        console.log(range.address);
+        console.log(range.font);`,
+    },
+    {
+      code: `
+        var range = worksheet.getSelectedRange();
+        range.load({ format: { fill: { color: true } }, address: true } );
+        await context.sync();
+        console.log(range.format.fill.color);
+        console.log(range.address);`,
+    },
+    {
+      code: `
+        const range = context.workbook.getSelectedRange();
+        const first = range.getCell(0, 0);
+        const spillParent = first.getSpillParentOrNullObject();
+        await context.sync();
+        const cell = spillParent.isNullObject ? first : spillParent;
+        console.log(cell);`,
+    },
+    {
+      code: `
+        var myRange = context.workbook.worksheets.getSelectedRange();
+        context.load(myRange, 'values');
+        console.log(myRange.values);`,
+    },
+    {
+      code: `
+        var myRange = context.workbook.worksheets.getSelectedRange();
+        context.load(myRange);
+        console.log(myRange.values);`,
+    },
+    {
+      code: `
+        var myRange = context.workbook.worksheets.getSelectedRange();
+        context.load(myRange, ['values', 'address']);
+        console.log(myRange.values);`,
+    },
+  ],
+  invalid: [
+    {
+      code: `
+        var sheetName = 'Sheet1';
+        var rangeAddress = 'A1:B2';
+        console.log(rangeAddress);
+        var myRange = context.workbook.worksheets.getItem(sheetName).getRange(rangeAddress);  
+        myRange.load('address');
+        context.sync()
+          .then(function () {
+            console.log (myRange.values);  // not ok as it was not loaded
+          });`,
+      errors: [
+        {
+          messageId: "loadBeforeRead",
+          data: { name: "myRange", loadValue: "values" },
+        },
+      ],
+    },
+    {
+      code: `
+        var selectedRange = context.workbook.getSelectedRange();
+        if(selectedRange.values === ["sampleText"]){}`,
+      errors: [
+        {
+          messageId: "loadBeforeRead",
+          data: { name: "selectedRange", loadValue: "values" },
+        },
+      ],
+    },
+    {
+      code: `
+        var myRange = context.workbook.worksheets.getItem("sheet").getRange("A1");
+        console.log (myRange.adress);`,
+      errors: [
+        {
+          messageId: "loadBeforeRead",
+          data: { name: "myRange", loadValue: "adress" },
+        },
+      ],
+    },
+    {
+      code: `
+        var selectedRange = context.workbook.getSelectedRange();
+        console.log(selectedRange.values);`,
+      errors: [
+        {
+          messageId: "loadBeforeRead",
+          data: { name: "selectedRange", loadValue: "values" },
+        },
+      ],
+    },
+    {
+      code: `
+        var selectedRange = context.workbook.getSelectedRange();
+        console.log(selectedRange.values);
+        selectedRange.load('values')`,
+      errors: [
+        {
+          messageId: "loadBeforeRead",
+          data: { name: "selectedRange", loadValue: "values" },
+        },
+      ],
+    },
+    {
+      code: `
+        var selectedRange = context.workbook.getSelectedRange();
+        var test = selectedRange.values;`,
+      errors: [
+        {
+          messageId: "loadBeforeRead",
+          data: { name: "selectedRange", loadValue: "values" },
+        },
+      ],
+    },
+    {
+      code: `
+        var myRange;
+        myRange = context.workbook.worksheets.getSelectedRange();
+        var test = myRange.values;`,
+      errors: [
+        {
+          messageId: "loadBeforeRead",
+          data: { name: "myRange", loadValue: "values" },
+        },
+      ],
+    },
+    {
+      code: `
+        var myRange = context.workbook.worksheets.getSelectedRange();
+        myRange = context.workbook.worksheets.getItem(sheetName).getRange(rangeAddress);
+        var test = myRange.values;`,
+      errors: [
+        {
+          messageId: "loadBeforeRead",
+          data: { name: "myRange", loadValue: "values" },
+        },
+      ],
+    },
+    {
+      code: `
+        var range = worksheet.getRange("A1");
+        range.load("range/format/fill/size");
+        console.log(range.format.fill.color);`,
+      errors: [
+        {
+          messageId: "loadBeforeRead",
+          data: { name: "range", loadValue: "format/fill/color" },
+        },
+      ],
+    },
+    {
+      code: `
+        var range = worksheet.getSelectedRange();
+        await context.sync();
+        console.log(range.font.fill.color);`,
+      errors: [
+        {
+          messageId: "loadBeforeRead",
+          data: { name: "range", loadValue: "font/fill/color" },
+        },
+      ],
+    },
+    {
+      code: `
+        var range = worksheet.getSelectedRange();
+        range.load({ format: { fill: { color: true } } } );
+        await context.sync();
+        console.log(range.format.fill.color);
+        console.log(range.address);`,
+      errors: [
+        {
+          messageId: "loadBeforeRead",
+          data: { name: "range", loadValue: "address" },
+        },
+      ],
+    },
+    {
+      code: `
+        var range = worksheet.getSelectedRange();
+        range.load({ format: { fill: { color: false } } } );
+        await context.sync();
+        console.log(range.format.fill.color);`,
+      errors: [
+        {
+          messageId: "loadBeforeRead",
+          data: { name: "range", loadValue: "format/fill/color" },
+        },
+      ],
+    },
+    {
+      code: `
+        var myRange = context.workbook.worksheets.getSelectedRange();
+        context.load("myRange", "values");
+        console.log(myRange.values);`,
+      errors: [
+        {
+          messageId: "loadBeforeRead",
+          data: { name: "myRange", loadValue: "values" },
+        },
+      ],
+    },
+    {
+      code: `
+        var myRange = context.workbook.worksheets.getSelectedRange();
+        context.load(myRange, "values", "address");
+        console.log(myRange.values);`,
+      errors: [
+        {
+          messageId: "loadBeforeRead",
+          data: { name: "myRange", loadValue: "values" },
+        },
+      ],
+    },
+  ],
+});

node_modules/eslint-plugin-office-addins/test/rules/no-context-sync-in-loop.test.ts

@@ -0,0 +1,53 @@
+import { RuleTester } from "@typescript-eslint/rule-tester";
+import rule from "../../src/rules/no-context-sync-in-loop";
+
+const ruleTester = new RuleTester();
+
+ruleTester.run("no-context-sync-in-loop", rule, {
+  valid: [
+    {
+      code: "context.sync()",
+    },
+    {
+      code: `Excel.run(async (context) => { 
+        context.sync(); 
+      });`,
+    },
+  ],
+  invalid: [
+    {
+      code: `Word.run(async (context) => { 
+          for(i = 0; i < 5; i++) { context.sync(); } 
+        });`,
+      errors: [{ messageId: "loopedSync" }],
+    },
+    {
+      code: `Excel.run(async (context) => { 
+          var person = { fname:\"John\", lname:\"Doe\", age:25 }; 
+          var x; 
+          for(x in person) { context.sync(); } 
+        });`,
+      errors: [{ messageId: "loopedSync" }],
+    },
+    {
+      code: `PowerPoint.run(async (context) => { 
+          var cars = ['BMW', 'Volvo', 'Mini']; 
+          var x; 
+          for(x of cars) { context.sync(); } 
+        });`,
+      errors: [{ messageId: "loopedSync" }],
+    },
+    {
+      code: `Word.run(async (context) => { 
+          while(true) { context.sync() } 
+        });`,
+      errors: [{ messageId: "loopedSync" }],
+    },
+    {
+      code: `Excel.run(async (context) => { 
+          do { context.sync() } while(true); 
+        });`,
+      errors: [{ messageId: "loopedSync" }],
+    },
+  ],
+});

node_modules/eslint-plugin-office-addins/test/rules/no-empty-load.test.ts

@@ -0,0 +1,80 @@
+import { RuleTester } from "@typescript-eslint/rule-tester";
+import rule from "../../src/rules/no-empty-load";
+
+const ruleTester = new RuleTester();
+
+ruleTester.run("no-empty-load", rule, {
+  valid: [
+    {
+      code: `
+        var sheetName = 'Sheet1';
+        var rangeAddress = 'A1:B2';
+        var myRange = context.workbook.worksheets.getItem(sheetName).getRange(rangeAddress);  
+        myRange.load('address');
+        context.sync()
+          .then(function () {
+            console.log (myRange.address);   // ok
+          });`,
+    },
+    {
+      code: `
+        var property = worksheet.getItem("sheet");
+        property.load('G2');
+        var variableName = property.G2;`,
+    },
+    {
+      code: `
+        const notProxyObject = anotherObject.thisIsNotAGetFunction();
+        notProxyObject.load();`,
+    },
+    {
+      code: `
+        var selectedRange = context.workbook.getSelectedRange();
+        selectedRange = "new variable";
+        selectedRange.load()`,
+    },
+    {
+      code: `
+        var selectedRange = context.workbook.getSelectedRange();
+        selectedRange.load("*")`,
+    },
+  ],
+  invalid: [
+    {
+      code: `
+        var selectedRange = context.workbook.getSelectedRange();
+        selectedRange.load();`,
+      errors: [{ messageId: "emptyLoad" }],
+    },
+    {
+      code: `
+        var selectedRange = context.workbook.getSelectedRange();
+        selectedRange.load("");`,
+      errors: [{ messageId: "emptyLoad" }],
+    },
+    {
+      code: `
+        var myRange;
+        myRange = context.workbook.worksheets.getSelectedRange();
+        myRange.load();
+        console.log(myRange.values);`,
+      errors: [{ messageId: "emptyLoad" }],
+    },
+    {
+      code: `
+        var myRange;
+        myRange = context.workbook.worksheets.getSelectedRange();
+        myRange.load(["address", "values", ""]);
+        console.log(myRange.values);`,
+      errors: [{ messageId: "emptyLoad" }],
+    },
+    {
+      code: `
+        var myRange;
+        myRange = context.workbook.worksheets.getSelectedRange();
+        myRange.load("address, values, ");
+        console.log(myRange.values);`,
+      errors: [{ messageId: "emptyLoad" }],
+    },
+  ],
+});

node_modules/eslint-plugin-office-addins/test/rules/no-navigational-load.test.ts

@@ -0,0 +1,186 @@
+import { RuleTester } from "@typescript-eslint/rule-tester";
+import rule from "../../src/rules/no-navigational-load";
+
+const ruleTester = new RuleTester();
+
+ruleTester.run("no-navigational-load", rule, {
+  valid: [
+    {
+      code: `
+        var range = worksheet.getRange("A1");
+        range.load("borders/fill/size");
+        console.log(range.borders.fill.size);`,
+    },
+    {
+      code: `
+        var selectedRange = context.workbook.getSelectedRange();
+        selectedRange.load("format/font/name");`,
+    },
+    {
+      code: `
+        var sheetName = 'Sheet1';
+        var rangeAddress = 'A1:B2';
+        var myRange = context.workbook.worksheets.getItem(sheetName).getRange(rangeAddress);  
+        myRange.load('address');
+        context.sync()
+          .then(function () {
+          console.log (myRange.address);   // ok
+          });`,
+    },
+    {
+      code: `
+                var selectedRange = context.workbook.getSelectedRange();
+                selectedRange.load('text'); // Scalar`,
+    },
+    {
+      code: `
+        var selectedRange = context.workbook.getSelectedRange();
+        selectedRange.load('values');
+        if(selectedRange.values === [2]){}`,
+    },
+    {
+      code: `
+        var myRange = context.workbook.worksheets.notAGet();
+        myRange.load('notAProperty');
+        var test = myRange.notAProperty;`,
+    },
+    {
+      code: `
+        var range = context.workbook.getRange();
+        range.load({borders: { fill: { color: true } } });
+        if (range.borders.fill.color);`,
+    },
+    {
+      code: `
+        var range = context.workbook.getRange();
+        range.borders.fill.load("color");
+        console.log(range.borders.fill.color);`,
+    },
+    {
+      code: `
+        var selectedRange = context.workbook.getSelectedRange();
+        selectedRange.load(''); // Empty`,
+    },
+    {
+      code: `
+        var selectedRange = context.workbook.getSelectedRange();
+        selectedRange.load(); // Empty`,
+    },
+    {
+      code: `
+			  var range = worksheet.getSelectedRange();
+			  range.load("font/fill/color, address");
+			  await context.sync();
+			  console.log(range.font.fill.color);
+			  console.log(range.address);`,
+    },
+    {
+      code: `
+			  var range = worksheet.getSelectedRange();
+			  range.load(["font/fill/color", "address"]);
+			  await context.sync();
+			  console.log(range.font.fill.color);
+			  console.log(range.address);`,
+    },
+    {
+      code: `
+			  var range = worksheet.getSelectedRange();
+			  range.load("*");
+			  await context.sync();
+			  console.log(range.font.fill.color);
+			  console.log(range.address);`,
+    },
+    {
+      code: `
+			  var range = worksheet.getSelectedRange();
+			  range.load({ format: { fill: { color: true } } });
+			  await context.sync();
+			  console.log(range.font.fill.color);`,
+    },
+  ],
+  invalid: [
+    {
+      code: `
+        var property = worksheet.getItem("sheet");
+        property.load('thisIsNotAProperty'); //Not a property`,
+      errors: [
+        {
+          messageId: "navigationalLoad",
+          data: { loadValue: "thisIsNotAProperty" },
+        },
+      ],
+    },
+    {
+      code: `
+        var property = worksheet.getItem("sheet");
+        property.load('styles'); // Navigational`,
+      errors: [
+        { messageId: "navigationalLoad", data: { loadValue: "styles" } },
+      ],
+    },
+    {
+      code: `
+        var property = worksheet.getItem("sheet");
+        context.load(property, 'styles'); // Navigational`,
+      errors: [
+        { messageId: "navigationalLoad", data: { loadValue: "styles" } },
+      ],
+    },
+    {
+      code: `
+        var range = worksheet.getRange("A1");
+        range.load('fill'); // Navigational`,
+      errors: [{ messageId: "navigationalLoad", data: { loadValue: "fill" } }],
+    },
+    {
+      code: `
+        var range = worksheet.getRange("A1");
+        context.load(range, 'fill'); // Navigational`,
+      errors: [{ messageId: "navigationalLoad", data: { loadValue: "fill" } }],
+    },
+    {
+      code: `
+        var range = worksheet.getRange("A1");
+        range.load("borders/fill");
+        console.log(range.borders.fill); // Navigational`,
+      errors: [
+        { messageId: "navigationalLoad", data: { loadValue: "borders/fill" } },
+      ],
+    },
+    {
+      code: `
+        var range = worksheet.getRange("A1");
+        context.load(range, "borders/fill");
+        console.log(range.borders.fill); // Navigational`,
+      errors: [
+        { messageId: "navigationalLoad", data: { loadValue: "borders/fill" } },
+      ],
+    },
+    {
+      code: `
+        var range = worksheet.getRange("A1");
+        range.load({borders: { fill: true } });`,
+      errors: [
+        { messageId: "navigationalLoad", data: { loadValue: "borders/fill" } },
+      ],
+    },
+    {
+      code: `
+        var range = context.workbook.getRange();
+        range.borders.load("fill");
+        console.log(range.borders.fill);`,
+      errors: [{ messageId: "navigationalLoad", data: { loadValue: "fill" } }],
+    },
+    {
+      code: `
+			  var range = worksheet.getSelectedRange();
+			  range.load("address, font/fill");
+			  await context.sync();
+			  console.log(range.font.fill.color);
+			  console.log(range.address);`,
+      errors: [
+        { messageId: "navigationalLoad", data: { loadValue: "font/fill" } },
+      ],
+    },
+  ],
+});

node_modules/eslint-plugin-office-addins/test/rules/no-office-initialize.test.ts

@@ -0,0 +1,55 @@
+import { RuleTester } from "@typescript-eslint/rule-tester";
+import rule from "../../src/rules/no-office-initialize";
+
+const ruleTester = new RuleTester();
+
+ruleTester.run("no-office-initialize", rule, {
+  valid: [
+    {
+      code: `Office.onReady();`,
+    },
+    {
+      code: `Office.onReady(function(info) {
+          console.log(info);
+        });`,
+    },
+    {
+      code: `Office.onReady()
+          .then(function() {
+            console.log("Testing Office.onReady followed by .then");
+          });`,
+    },
+    {
+      code: `(async () => {
+          await Office.onReady();
+            console.log("Testing Office.onReady followed by await");
+        })();`,
+    },
+  ],
+  invalid: [
+    {
+      code: `Office.initialize = function () {};`,
+      errors: [{ messageId: "noOfficeInitialize" }],
+    },
+    {
+      code: `Office.initialize = function () {
+          console.log("Testing Office.initialize with normal function");
+        };`,
+      errors: [{ messageId: "noOfficeInitialize" }],
+    },
+    {
+      code: `Office.initialize = function (reason) {
+          $(document).ready(function () {
+              console.log(reason);
+          });
+        };`,
+      errors: [{ messageId: "noOfficeInitialize" }],
+    },
+    {
+      code: `Office.initialize = () => {
+          console.log("Testing Office.initialize with arrow function");
+        };`,
+      errors: [{ messageId: "noOfficeInitialize" }],
+    },
+  ],
+});

node_modules/eslint-plugin-office-addins/test/rules/test-for-null-using-isNullObject.test.ts

@@ -0,0 +1,214 @@
+import { RuleTester, TestCaseError } from "@typescript-eslint/rule-tester";
+import rule from "../../src/rules/test-for-null-using-isNullObject";
+
+const ruleTester = new RuleTester();
+
+const errors: TestCaseError<"useIsNullObject">[] = [
+  { messageId: "useIsNullObject", data: { name: "dataSheet" } },
+];
+
+ruleTester.run("test-for-null-using-isNullObject", rule, {
+  valid: [
+    {
+      code: `
+      await Excel.run(async (context) =>  {
+        var dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+        return context.sync().then(function () {
+            if (dataSheet.isNullObject) {
+              dataSheet = context.workbook.worksheets.add("Data");
+            }
+            dataSheet.position = 1;
+         });
+      });`,
+    },
+    {
+      code: `
+      var dataSheet;
+      dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+      return context.sync().then(function () {
+        if (dataSheet.isNullObject) {
+          dataSheet = context.workbook.worksheets.add("Data");
+        }
+        dataSheet.position = 1;
+      });`,
+    },
+    {
+      code: `
+      var dataSheet;
+      dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+      if (dataSheet.isNullObject) {
+        dataSheet = context.workbook.worksheets.add("Data");
+      }`,
+    },
+  ],
+  invalid: [
+    {
+      code: `
+      await Excel.run(async (context) =>  {
+        var dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+        return context.sync().then(function () {
+          if (dataSheet) {
+            dataSheet = context.workbook.worksheets.add("Data");
+          }
+          dataSheet.position = 1;
+        });
+      });`,
+      errors,
+      output: `
+      await Excel.run(async (context) =>  {
+        var dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+        return context.sync().then(function () {
+          if (dataSheet.isNullObject) {
+            dataSheet = context.workbook.worksheets.add("Data");
+          }
+          dataSheet.position = 1;
+        });
+      });`,
+    },
+    {
+      code: `
+      var dataSheet;
+      dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+      return context.sync().then(function () {
+        if (dataSheet) {
+          dataSheet = context.workbook.worksheets.add("Data");
+        }
+        dataSheet.position = 1;
+      });`,
+      errors,
+      output: `
+      var dataSheet;
+      dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+      return context.sync().then(function () {
+        if (dataSheet.isNullObject) {
+          dataSheet = context.workbook.worksheets.add("Data");
+        }
+        dataSheet.position = 1;
+      });`,
+    },
+    {
+      code: `
+      var dataSheet;
+      dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+      if (dataSheet) {
+        dataSheet = context.workbook.worksheets.add("Data");
+      }`,
+      errors,
+      output: `
+      var dataSheet;
+      dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+      if (dataSheet.isNullObject) {
+        dataSheet = context.workbook.worksheets.add("Data");
+      }`,
+    },
+    {
+      code: `
+      var dataSheet;
+      dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+      return context.sync().then(function () {
+        if (!dataSheet) {
+          dataSheet = context.workbook.worksheets.add("Data");
+        }
+        dataSheet.position = 1;
+      });`,
+      errors,
+      output: `
+      var dataSheet;
+      dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+      return context.sync().then(function () {
+        if (!dataSheet.isNullObject) {
+          dataSheet = context.workbook.worksheets.add("Data");
+        }
+        dataSheet.position = 1;
+      });`,
+    },
+    {
+      code: `
+      var dataSheet;
+      dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+      return context.sync().then(function () {
+        if (true && dataSheet) {
+          dataSheet = context.workbook.worksheets.add("Data");
+        }
+        dataSheet.position = 1;
+      });`,
+      errors,
+      output: `
+      var dataSheet;
+      dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+      return context.sync().then(function () {
+        if (true && dataSheet.isNullObject) {
+          dataSheet = context.workbook.worksheets.add("Data");
+        }
+        dataSheet.position = 1;
+      });`,
+    },
+    {
+      code: `
+      var dataSheet;
+      dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+      return context.sync().then(function () {
+        if (null != dataSheet) {
+          dataSheet = context.workbook.worksheets.add("Data");
+        }
+        dataSheet.position = 1;
+      });`,
+      errors,
+      output: `
+      var dataSheet;
+      dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+      return context.sync().then(function () {
+        if (dataSheet.isNullObject) {
+          dataSheet = context.workbook.worksheets.add("Data");
+        }
+        dataSheet.position = 1;
+      });`,
+    },
+    {
+      code: `
+      var dataSheet;
+      dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+      return context.sync().then(function () {
+        for (var i = 0; i < 5; i++) {
+          if (dataSheet) {
+            dataSheet = context.workbook.worksheets.add("Data");
+          }
+        }
+        dataSheet.position = 1;
+      });`,
+      errors,
+      output: `
+      var dataSheet;
+      dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+      return context.sync().then(function () {
+        for (var i = 0; i < 5; i++) {
+          if (dataSheet.isNullObject) {
+            dataSheet = context.workbook.worksheets.add("Data");
+          }
+        }
+        dataSheet.position = 1;
+      });`,
+    },
+    {
+      code: `
+      var dataSheet;
+      dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+      return context.sync().then(function () {
+        do {
+          console.log("test case");
+        } while (dataSheet);
+        dataSheet.position = 1;
+      });`,
+      errors,
+      output: `
+      var dataSheet;
+      dataSheet = context.workbook.worksheets.getItemOrNullObject("Data");
+      return context.sync().then(function () {
+        do {
+          console.log("test case");
+        } while (dataSheet.isNullObject);
+        dataSheet.position = 1;
+      });`,
+    },
+  ],
+});