feat: requirejs indexer

Author: raideer

package-lock.json

@@ -427,6 +427,8 @@
     "@xml-tools/parser": "^1.0.11",
     "@xml-tools/simple-schema": "^3.0.5",
     "@xml-tools/validation": "^1.0.16",
+    "acorn": "^8.14.1",
+    "acorn-walk": "^8.3.4",
     "fast-xml-parser": "^4.5.1",
     "formik": "^2.4.6",
     "glob": "^11.0.1",

package.json

@@ -18,14 +18,17 @@ import AclIndexer from './acl/AclIndexer';
 import { AclIndexData } from './acl/AclIndexData';
 import TemplateIndexer from './template/TemplateIndexer';
 import { TemplateIndexData } from './template/TemplateIndexData';
+import RequireJsIndexer from './require-js/RequireJsIndexer';
+import { RequireJsIndexData } from './require-js/RequireJsIndexData';
 
 type IndexerInstance =
   | DiIndexer
   | ModuleIndexer
   | AutoloadNamespaceIndexer
   | EventsIndexer
   | AclIndexer
-  | TemplateIndexer;
+  | TemplateIndexer
+  | RequireJsIndexer;
 
 type IndexerDataMap = {
   [DiIndexer.KEY]: DiIndexData;
@@ -34,6 +37,7 @@ type IndexerDataMap = {
   [EventsIndexer.KEY]: EventsIndexData;
   [AclIndexer.KEY]: AclIndexData;
   [TemplateIndexer.KEY]: TemplateIndexData;
+  [RequireJsIndexer.KEY]: RequireJsIndexData;
 };
 
 class IndexManager {
@@ -48,6 +52,7 @@ class IndexManager {
       new EventsIndexer(),
       new AclIndexer(),
       new TemplateIndexer(),
+      new RequireJsIndexer(),
     ];
     this.indexStorage = new IndexStorage();
   }
@@ -181,6 +186,9 @@ class IndexManager {
       case TemplateIndexer.KEY:
         return new TemplateIndexData(data) as IndexerDataMap[T];
 
+      case RequireJsIndexer.KEY:
+        return new RequireJsIndexData(data) as IndexerDataMap[T];
+
       default:
         return undefined;
     }

src/indexer/IndexManager.ts

@@ -0,0 +1,5 @@
+import { AbstractIndexData } from 'indexer/AbstractIndexData';
+import RequireJsIndexer from './RequireJsIndexer';
+import { Map } from './types';
+
+export class RequireJsIndexData extends AbstractIndexData<Map[]> {}

src/indexer/require-js/RequireJsIndexData.ts

@@ -0,0 +1,156 @@
+import { RelativePattern, Uri } from 'vscode';
+import { Indexer } from 'indexer/Indexer';
+import { IndexerKey } from 'types/indexer';
+import { Map } from './types';
+import FileSystem from 'util/FileSystem';
+import {
+  AssignmentProperty,
+  Identifier,
+  Literal,
+  Node,
+  ObjectExpression,
+  Property,
+  VariableDeclaration,
+  VariableDeclarator,
+  parse,
+} from 'acorn';
+import * as walk from 'acorn-walk';
+import { RequireJsConfig } from './types';
+
+export default class RequireJsIndexer extends Indexer<RequireJsConfig> {
+  public static readonly KEY = 'require-js';
+
+  public getVersion(): number {
+    return 1;
+  }
+
+  public getId(): IndexerKey {
+    return RequireJsIndexer.KEY;
+  }
+
+  public getName(): string {
+    return 'requirejs-config.js';
+  }
+
+  public getPattern(uri: Uri): RelativePattern {
+    return new RelativePattern(uri, '**/view/**/requirejs-config.js');
+  }
+
+  public async indexFile(uri: Uri): Promise<RequireJsConfig | undefined> {
+    const js = await FileSystem.readFile(uri);
+    const ast = parse(js, { ecmaVersion: 2020 });
+
+    // Find config identifier
+    const configVariableDeclarator = await this.findConfigVariableDeclarator(ast);
+
+    if (!configVariableDeclarator) {
+      return undefined;
+    }
+
+    const config: RequireJsConfig = {
+      map: {},
+      paths: {},
+    };
+
+    await this.processMaps(config, configVariableDeclarator);
+    await this.processPaths(config, configVariableDeclarator);
+
+    return config;
+  }
+
+  private async processMaps(config: RequireJsConfig, configVariableDeclarator: VariableDeclarator) {
+    const mapProperty = await this.findProperty(configVariableDeclarator, 'map');
+
+    if (!mapProperty) {
+      return config;
+    }
+
+    const objectExpression = mapProperty.value as ObjectExpression;
+    const properties = objectExpression.properties as Property[];
+
+    for (const property of properties) {
+      const group = (property.key as Literal).value as string;
+      const mappings = this.getGroupMappings(property);
+
+      config.map[group] = mappings;
+    }
+  }
+
+  private async processPaths(
+    config: RequireJsConfig,
+    configVariableDeclarator: VariableDeclarator
+  ) {
+    const pathsProperty = await this.findProperty(configVariableDeclarator, 'paths');
+
+    if (!pathsProperty) {
+      return config;
+    }
+
+    const objectExpression = pathsProperty.value as ObjectExpression;
+    const properties = objectExpression.properties as Property[];
+
+    for (const property of properties) {
+      const key = (property.key as Literal).value as string;
+      const value = (property.value as Literal).value as string;
+
+      config.paths[key] = value;
+    }
+  }
+
+  private getGroupMappings(property: Property): Record<string, string> {
+    const objectExpression = property.value as ObjectExpression;
+    const properties = objectExpression.properties as Property[];
+
+    const mappings: Record<string, string> = {};
+
+    for (const property of properties) {
+      const key =
+        property.key.type === 'Literal'
+          ? (property.key as Literal).value
+          : (property.key as Identifier).name;
+      const value =
+        property.value.type === 'Literal'
+          ? (property.value as Literal).value
+          : (property.value as Identifier).name;
+
+      mappings[key as string] = value as string;
+    }
+
+    return mappings;
+  }
+
+  private findConfigVariableDeclarator(ast: Node): Promise<VariableDeclarator | undefined> {
+    return new Promise((resolve, reject) => {
+      walk.simple(ast, {
+        VariableDeclaration(node: VariableDeclaration) {
+          node.declarations.forEach(declarator => {
+            if (declarator.id.type === 'Identifier' && declarator.id.name === 'config') {
+              resolve(declarator);
+            }
+          });
+        },
+      });
+
+      resolve(undefined);
+    });
+  }
+
+  private findProperty(
+    variableDeclarator: VariableDeclarator,
+    key: string
+  ): Promise<Property | AssignmentProperty | undefined> {
+    return new Promise(resolve => {
+      const objectExpression = variableDeclarator.init as ObjectExpression;
+
+      walk.simple(objectExpression, {
+        Property(node: Property | AssignmentProperty) {
+          if (node.key.type === 'Identifier' && node.key.name === key) {
+            resolve(node);
+          }
+        },
+      });
+
+      resolve(undefined);
+    });
+  }
+}

src/indexer/require-js/RequireJsIndexer.ts

@@ -0,0 +1,4 @@
+export interface RequireJsConfig {
+  map: Record<string, Record<string, string>>;
+  paths: Record<string, string>;
+}