Improve some types and fix tokenTypes transformation

Author: andrewbranch

src/getPossibleThemes.js

@@ -8,10 +8,10 @@ const {
 
 /**
  * @param {ThemeOption} themeOption
- * @param {object} themeCache
+ * @param {ThemeCache} themeCache
  * @param {string | undefined} contextDirectory
  * @param {MarkdownNode} markdownNode
- * @param {object} codeFenceNode
+ * @param {MDASTNode} codeFenceNode
  * @param {string} languageName
  * @param {object} meta
  * @returns {Promise<ConditionalTheme[]>}

src/graphql/getThemes.js

@@ -5,7 +5,7 @@ const parseThemeCondition = require('./parseThemeCondition');
 
 /**
  * @param {grvsc.gql.GRVSCThemeArgument} theme
- * @param {any} themeCache
+ * @param {ThemeCache} themeCache
  * @returns {Promise<ConditionalTheme>}
  */
 async function convertThemeArgument(theme, themeCache) {
@@ -19,7 +19,7 @@ async function convertThemeArgument(theme, themeCache) {
 /**
  * @param {ThemeOption} themeOption
  * @param {grvsc.gql.CSSArgs} args
- * @param {any} themeCache
+ * @param {ThemeCache} themeCache
  * @returns {Promise<ConditionalTheme[]>}
  */
 async function getThemes(themeOption, args, themeCache) {

src/processExtension.js

@@ -19,63 +19,64 @@ const requireMain = createRequire(require.main.filename);
  */
 async function processExtension(packageJsonPath) {
   const packageJson = requireJson(packageJsonPath);
+  /** @type {Record<string, GrammarData>} */
   let grammars = {};
+  /** @type {Record<string, ThemeData>} */
   let themes = {};
   if (packageJson.contributes && packageJson.contributes.grammars) {
     const manifest = await Promise.all(
-      packageJson.contributes.grammars.map(async grammar => {
-        const sourcePath = path.resolve(path.dirname(packageJsonPath), grammar.path);
-        const content = await requirePlistOrJson(sourcePath);
-        const { scopeName } = content;
-        const languageRegistration = packageJson.contributes.languages.find(l => l.id === grammar.language);
-        const languageNames = languageRegistration ? getLanguageNames(languageRegistration) : [];
-        logger.info(
-          `Registering grammar '${scopeName}' from package ${packageJson.name} with language names: ${languageNames}`
-        );
-
-        return {
-          scopeName,
-          path: sourcePath,
-          tokenTypes: grammar.tokenTypes,
-          embeddedLanguages: grammar.embeddedLanguages,
-          injectTo: grammar.injectTo,
-          languageNames
-        };
-      })
+      packageJson.contributes.grammars.map(
+        /** @returns {Promise<GrammarData>} */ async grammar => {
+          const sourcePath = path.resolve(path.dirname(packageJsonPath), grammar.path);
+          const content = await requirePlistOrJson(sourcePath);
+          const { scopeName } = content;
+          const languageRegistration = packageJson.contributes.languages.find(l => l.id === grammar.language);
+          const languageNames = languageRegistration ? getLanguageNames(languageRegistration) : [];
+          logger.info(
+            `Registering grammar '${scopeName}' from package ${packageJson.name} with language names: ${languageNames}`
+          );
+
+          return {
+            languageId: 0, // Overwritten elsewhere
+            scopeName,
+            path: sourcePath,
+            tokenTypes: toStandardTokenTypes(grammar.tokenTypes),
+            embeddedLanguages: grammar.embeddedLanguages,
+            injectTo: grammar.injectTo,
+            languageNames
+          };
+        }
+      )
     );
 
     grammars = manifest.reduce(
       (hash, grammar) => ({
         ...hash,
-        [grammar.scopeName]: {
-          path: grammar.path,
-          tokenTypes: grammar.tokenTypes,
-          embeddedLanguages: grammar.embeddedLanguages,
-          injectTo: grammar.injectTo,
-          languageNames: grammar.languageNames
-        }
+        [grammar.scopeName]: grammar
       }),
       {}
     );
   }
 
   if (packageJson.contributes && packageJson.contributes.themes) {
     const manifest = await Promise.all(
-      packageJson.contributes.themes.map(async theme => {
-        const sourcePath = path.resolve(path.dirname(packageJsonPath), theme.path);
-        const themeContents = await requirePlistOrJson(sourcePath);
-        const id = theme.id || path.basename(theme.path).split('.')[0];
-        logger.info(`Registering theme '${theme.label || id}' from package ${packageJson.name}`);
-
-        return {
-          id,
-          path: sourcePath,
-          label: theme.label,
-          include: themeContents.include,
-          packageName: packageJson.name,
-          isOnlyThemeInPackage: packageJson.contributes.themes.length === 1
-        };
-      })
+      packageJson.contributes.themes.map(
+        /** @returns {Promise<ThemeData>} */ async theme => {
+          const sourcePath = path.resolve(path.dirname(packageJsonPath), theme.path);
+          const themeContents = await requirePlistOrJson(sourcePath);
+          const id = theme.id || path.basename(theme.path).split('.')[0];
+          logger.info(`Registering theme '${theme.label || id}' from package ${packageJson.name}`);
+
+          return {
+            id,
+            path: sourcePath,
+            label: theme.label,
+            include: themeContents.include,
+            packageName: packageJson.name,
+            isOnlyThemeInPackage: packageJson.contributes.themes.length === 1
+          };
+        }
+      )
     );
 
     themes = manifest.reduce(
@@ -91,7 +92,7 @@ async function processExtension(packageJsonPath) {
 }
 
 /**
- * @param {*} cache
+ * @param {GatsbyCache} cache
  * @param {string} key
  * @param {object} value
  */
@@ -139,7 +140,7 @@ async function getExtensionPackageJsonPath(specifier, host) {
 /**
  * @param {string[]} extensions
  * @param {Host} host
- * @param {*} cache
+ * @param {GatsbyCache} cache
  */
 async function processExtensions(extensions, host, cache) {
   let languageId = getHighestBuiltinLanguageId() + 1;
@@ -152,4 +153,38 @@ async function processExtensions(extensions, host, cache) {
   }
 }
 
+/**
+ * @param {Record<string, string> | undefined} tokenTypes
+ * @returns {import('vscode-textmate').ITokenTypeMap}
+ */
+function toStandardTokenTypes(tokenTypes) {
+  return (
+    tokenTypes &&
+    Object.keys(tokenTypes).reduce(
+      (map, selector) => ({
+        ...map,
+        [selector]: toStandardTokenType(tokenTypes[selector])
+      }),
+      {}
+    )
+  );
+}
+
+/**
+ * @param {string} tokenType
+ * @returns {import('vscode-textmate').StandardTokenType}
+ */
+function toStandardTokenType(tokenType) {
+  switch (tokenType.toLowerCase()) {
+    case 'comment':
+      return 1;
+    case 'string':
+      return 2;
+    case 'regex':
+      return 4;
+    default:
+      return 0;
+  }
+}
+
 module.exports = { processExtension, processExtensions };

src/storeUtils.js

@@ -6,10 +6,14 @@ const { exists } = require('./utils');
 let grammarManifest;
 /** @type {void} */
 let themeManifest;
+
+/** @returns {GrammarCache} */
 function getGrammarManifest() {
   // @ts-ignore
   return grammarManifest || (grammarManifest = require('../lib/grammars/manifest.json'));
 }
+
+/** @returns {ThemeCache} */
 function getThemeManifest() {
   // @ts-ignore
   return themeManifest || (themeManifest = require('../lib/themes/manifest.json'));
@@ -25,7 +29,7 @@ function resolveAlias(language, languageAliases) {
 
 /**
  * @param {string} language
- * @param {*} grammarCache
+ * @param {GrammarCache} grammarCache
  * @param {Record<string, string>} languageAliases
  */
 function getScope(language, grammarCache, languageAliases) {
@@ -40,7 +44,7 @@ function getScope(language, grammarCache, languageAliases) {
 }
 
 /**
- * @param {*} grammar
+ * @param {GrammarData} grammar
  */
 function getGrammarLocation(grammar) {
   return path.isAbsolute(grammar.path) ? grammar.path : path.resolve(__dirname, '../lib/grammars', grammar.path);
@@ -49,7 +53,7 @@ function getGrammarLocation(grammar) {
 /**
  *
  * @param {string} themeNameOrId
- * @param {object} themeCache
+ * @param {ThemeCache} themeCache
  * @param {string=} contextDirectory
  * @returns {Promise<string>}
  */
@@ -91,14 +95,15 @@ function getHighestBuiltinLanguageId() {
 
 /**
  * @param {string} scopeName
- * @param {*} grammarCache
+ * @param {GrammarCache} grammarCache
  */
 function getGrammar(scopeName, grammarCache) {
   return getAllGrammars(grammarCache)[scopeName];
 }
 
 /**
- * @param {*} grammarCache
+ * @param {GrammarCache} grammarCache
+ * @returns {GrammarCache}
  */
 function getAllGrammars(grammarCache) {
   return { ...getGrammarManifest(), ...grammarCache };

src/themeUtils.js

@@ -73,7 +73,7 @@ function concatConditionalThemes(arr1, arr2) {
 
 /**
  * @param {string} identifier
- * @param {any} themeCache
+ * @param {ThemeCache} themeCache
  * @param {string=} contextDirectory
  * @returns {Promise<ConditionalTheme>}
  */
@@ -88,7 +88,7 @@ async function createDefaultTheme(identifier, themeCache, contextDirectory) {
 /**
  * @param {string} identifier
  * @param {string} match
- * @param {any} themeCache
+ * @param {ThemeCache} themeCache
  * @param {string=} contextDirectory
  * @returns {Promise<ConditionalTheme>}
  */
@@ -103,7 +103,7 @@ async function createMatchMediaTheme(identifier, match, themeCache, contextDirec
 /**
  * @param {string} identifier
  * @param {string} parentSelector
- * @param {any} themeCache
+ * @param {ThemeCache} themeCache
  * @param {string=} contextDirectory
  * @returns {Promise<ConditionalTheme>}
  */

src/types.d.ts

@@ -66,7 +66,31 @@ interface PluginOptions {
   getLineTransformers?: (pluginOptions: PluginOptions, cache: GatsbyCache) => LineTransformer[];
 }
 
+interface GrammarData {
+  scopeName: string;
+  languageId: number;
+  path: string;
+  tokenTypes: import('vscode-textmate').ITokenTypeMap | undefined;
+  embeddedLanguages: Record<string, string> | undefined;
+  injectTo: string[] | undefined;
+  languageNames: string[];
+}
+
+interface ThemeData {
+  id: string;
+  path: string;
+  label: string;
+  include: string | undefined;
+  packageName: string;
+  isOnlyThemeInPackage: boolean;
+}
+
+type GrammarCache = Record<string, GrammarData>;
+type ThemeCache = Record<string, ThemeData>;
+
 interface GatsbyCache {
+  get(key: 'grammars'): Promise<GrammarCache>;
+  get(key: 'themes'): Promise<ThemeCache>;
   get(key: string): Promise<any>;
   set(key: string, data: any): Promise<void>;
 }

src/utils.js

@@ -93,9 +93,9 @@ function getMetadataForToken(token, binaryTokens) {
 }
 
 /**
- * @param {*} cache
+ * @param {GatsbyCache} cache
  * @param {string} key
- * @param {object} value
+ * @param {Record<string, any>} value
  */
 async function mergeCache(cache, key, value) {
   await cache.set(key, { ...(await cache.get(key)), ...value });