feat(TypeScript): Update types

test/test-browsers.js

@@ -1,6 +1,10 @@
 'use strict';
 const path = require('path');
 
+/**
+ * @typedef {import('../types').Identifier} Identifier
+ */
+
 /** @type {Record<string, string[]>} */
 const browsers = {
   desktop: [
@@ -38,7 +42,7 @@ const browsers = {
 };
 
 /**
- * @param {*} data
+ * @param {Identifier} data
  * @param {string[]} displayBrowsers
  * @param {string[]} requiredBrowsers
  * @param {string} category
@@ -74,6 +78,7 @@ function processData(data, displayBrowsers, requiredBrowsers, category, logger,
 function testBrowsers(filename) {
   const relativePath = path.relative(path.resolve(__dirname, '..'), filename);
   const category = relativePath.includes(path.sep) && relativePath.split(path.sep)[0];
+  /** @type {Identifier} */
   const data = require(filename);
 
   if (!category || category === "test") {

test/test-regexes.js

@@ -1,13 +1,31 @@
 const assert = require('assert');
 
+/**
+ * @typedef {import('../types').Identifier} Identifier
+ *
+ * @typedef {object} TestCase
+ * @property {string[]} features
+ * @property {string[]} matches
+ * @property {string[]} misses
+ */
+
+/** @type {Identifier} */
 const bcd = require('..');
 
+/**
+ * @param {string} dottedFeature
+ */
 function lookup(dottedFeature) {
   const x = dottedFeature.split('.');
   const feature = x.reduce((prev, current) => prev[current], bcd);
   return feature;
 }
 
+/**
+ * @param {Identifier} feature
+ * @param {string[]} matches
+ * @param {string[]} misses
+ */
 function testToken(feature, matches, misses) {
   const str = feature.__compat.matches.regex_token || feature.__compat.matches.regex_value;
   const regexp = new RegExp(str);
@@ -16,6 +34,7 @@ function testToken(feature, matches, misses) {
   misses.forEach(miss => assert.ok(!regexp.test(miss), `${regexp} erroneously matched ${miss}`));
 }
 
+/** @type {TestCase[]} */
 const tests = [
   {
     features: [

test/test-schema.js

@@ -5,6 +5,10 @@ const path = require('path');
 
 const ajv = new Ajv({ jsonPointers: true, allErrors: true });
 
+/**
+ * @param {string} dataFilename
+ * @param {string} [schemaFilename]
+ */
 function testSchema(dataFilename, schemaFilename = './../schemas/compat-data.schema.json') {
   const schema = require(schemaFilename);
   const data   = require(dataFilename);

test/test-style.js

@@ -44,6 +44,11 @@ function escapeInvisibles(str) {
   return finalString;
 }
 
+/**
+ * @param {string} actual
+ * @param {string} expected
+ * @return {string}
+ */
 function jsonDiff(actual, expected) {
   var actualLines = actual.split(/\n/);
   var expectedLines = expected.split(/\n/);
@@ -59,6 +64,9 @@ function jsonDiff(actual, expected) {
   }
 }
 
+/**
+ * @param {string} filename
+ */
 function testStyle(filename) {
   let hasErrors = false;
   let actual = fs.readFileSync(filename, 'utf-8').trim();

test/test-versions.js

@@ -1,13 +1,24 @@
 'use strict';
 const path = require('path');
-const browsers = require('..').browsers;
 const compareVersions = require('compare-versions');
+/**
+ * @typedef {import('../types').Identifier} Identifier
+ * @typedef {import('../types').SimpleSupportStatement} SimpleSupportStatement
+ * @typedef {import('../types').SupportBlock} SupportBlock
+ * @typedef {import('../types').VersionValue} VersionValue
+ */
+const browsers = require('..').browsers;
 
+/** @type {Object<string, string[]>} */
 const validBrowserVersions = {};
 for (const browser of Object.keys(browsers)) {
   validBrowserVersions[browser] = Object.keys(browsers[browser].releases);
 }
 
+/**
+ * @param {string} browserIdentifier
+ * @param {VersionValue} version
+ */
 function isValidVersion(browserIdentifier, version) {
   if (typeof version === "string") {
     return validBrowserVersions[browserIdentifier].includes(version);
@@ -16,15 +27,21 @@ function isValidVersion(browserIdentifier, version) {
   }
 }
 
+/**
+ * @param {string} dataFilename
+ */
 function testVersions(dataFilename) {
   const data = require(dataFilename);
   let hasErrors = false;
 
+  /**
+   * @param {SupportBlock} supportData
+   */
   function checkVersions(supportData) {
     const browsersToCheck = Object.keys(supportData);
     for (const browser of browsersToCheck) {
       if (validBrowserVersions[browser]) {
-
+        /** @type {SimpleSupportStatement[]} */
         const supportStatements = [];
         if (Array.isArray(supportData[browser])) {
           Array.prototype.push.apply(supportStatements, supportData[browser]);
@@ -58,10 +75,13 @@ function testVersions(dataFilename) {
     }
   }
 
+  /**
+   * @param {Identifier} data
+   */
   function findSupport(data) {
     for (const prop in data) {
-      if (prop === 'support') {
-        checkVersions(data[prop]);
+      if (prop === '__compat' && data[prop].support) {
+        checkVersions(data[prop].support);
       }
       const sub = data[prop];
       if (typeof(sub) === "object") {

types.d.ts

@@ -1,8 +1,6 @@
 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/ */
 
-export as namespace bcd;
-
 /**
  * The names of the known browsers.
  */
@@ -241,6 +239,8 @@ export interface CompatStatement {
    */
   mdn_url?: string;
 
+  matches?: MatchesBlock;
+
   /**
    * Each `__compat` object contains support information.
    *
@@ -262,6 +262,12 @@ export interface SupportBlock
   extends Partial<Record<BrowserNames, SupportStatement>>,
     Partial<Record<string, SupportStatement>> {}
 
+export interface MatchesBlock {
+  keywords?: string[];
+  regex_token?: string;
+  regex_value?: string;
+}
+
 /**
  * The status property contains information about stability of the feature.
  */