Introduce environments

.eslintrc

@@ -9,6 +9,7 @@
   ],
   "rules": {
     "prefer-const": "off",
+    "require-yield": "off",
     "@typescript-eslint/prefer-const": "off",
     "@typescript-eslint/no-empty-function": "off",
     "@typescript-eslint/no-empty-interface": "off",

.gitignore

@@ -1,2 +1,3 @@
 node_modules
 yarn-error.log
+test-packages/ephemeral

packages/cli/__tests__/check.test.ts

@@ -129,7 +129,7 @@ describe('single-pass typechecking', () => {
     `;
 
     project.write('index.ts', code);
-    project.write('.glintrc', 'exclude: "index.ts"\n');
+    project.write('.glintrc', 'environment: glimmerx\nexclude: "index.ts"\n');
 
     let checkResult = await project.check();
 

packages/cli/__tests__/declaration.test.ts

@@ -13,7 +13,6 @@ describe('emitting declarations', () => {
 
   test('emit for a valid project', async () => {
     let code = stripIndent`
-      import '@glint/template/glimmerx';
       import Component, { hbs } from '@glimmerx/component';
 
       export interface ApplicationArgs {
@@ -37,8 +36,7 @@ describe('emitting declarations', () => {
     expect(emitResult.exitCode).toBe(0);
 
     expect(project.read('index.d.ts')).toMatchInlineSnapshot(`
-      "import '@glint/template/glimmerx';
-      import Component from '@glimmerx/component';
+      "import Component from '@glimmerx/component';
       export interface ApplicationArgs {
           version: string;
       }

packages/cli/__tests__/utils/project.ts

@@ -1,10 +1,11 @@
 import path from 'path';
-import os from 'os';
 import fs from 'fs';
 import execa, { ExecaChildProcess, Options } from 'execa';
 
+const ROOT = path.resolve(__dirname, '../../../../test-packages/ephemeral');
+
 export default class Project {
-  private rootDir = path.join(os.tmpdir(), Math.random().toString(16).slice(2));
+  private rootDir = path.join(ROOT, Math.random().toString(16).slice(2));
 
   private constructor() {}
 
@@ -18,7 +19,6 @@ export default class Project {
     let project = new Project();
     let tsconfig = {
       compilerOptions: {
-        plugins: [{ name: path.resolve(__dirname, '../lib') }],
         strict: true,
         target: 'es2019',
         module: 'es2015',
@@ -29,17 +29,14 @@ export default class Project {
     };
 
     fs.rmdirSync(project.rootDir, { recursive: true });
-    fs.mkdirSync(project.rootDir);
+    fs.mkdirSync(project.rootDir, { recursive: true });
 
+    fs.writeFileSync(path.join(project.rootDir, 'package.json'), '{}');
+    fs.writeFileSync(path.join(project.rootDir, '.glintrc'), 'environment: glimmerx\n');
     fs.writeFileSync(
       path.join(project.rootDir, 'tsconfig.json'),
       JSON.stringify(tsconfig, null, 2)
     );
-    fs.writeFileSync(path.join(project.rootDir, 'package.json'), '{}');
-
-    project.linkPackage('@glint/template');
-    project.linkPackage('@glimmerx/component');
-    project.linkPackage('typescript');
 
     return project;
   }
@@ -66,14 +63,6 @@ export default class Project {
   public watch(options?: Options): Watch {
     return new Watch(this.check({ ...options, flags: ['--watch'], reject: false }));
   }
-
-  private linkPackage(name: string): void {
-    let linkPath = path.join(this.rootDir, 'node_modules', name);
-    let linkTarget = path.dirname(require.resolve(`${name}/package.json`));
-
-    fs.mkdirSync(path.dirname(linkPath), { recursive: true });
-    fs.symlinkSync(linkTarget, linkPath, 'dir');
-  }
 }
 
 class Watch {

packages/cli/src/perform-check.ts

@@ -36,6 +36,7 @@ function collectDiagnostics(
     ...program.getSyntacticDiagnostics(),
     ...transformManager.getTransformDiagnostics(),
     ...program.getSemanticDiagnostics(),
+    ...program.getDeclarationDiagnostics(),
   ];
 }
 

packages/cli/src/transform-manager.ts

@@ -36,15 +36,16 @@ export default class TransformManager {
 
   public readFile(filename: string, encoding?: string): string | undefined {
     let source = this.ts.sys.readFile(filename, encoding);
+    let config = this.glintConfig;
 
-    // TODO: don't hard-code the relevant import we're interested in
     if (
+      source &&
       filename.endsWith('.ts') &&
       !filename.endsWith('.d.ts') &&
-      source?.includes('@glimmerx/component') &&
-      this.glintConfig.includesFile(filename)
+      config.includesFile(filename) &&
+      config.environment.moduleMayHaveTagImports(source)
     ) {
-      let transformedModule = rewriteModule(filename, source);
+      let transformedModule = rewriteModule(filename, source, config.environment);
       if (transformedModule) {
         this.transformedModules.set(filename, transformedModule);
         return transformedModule.transformedSource;

packages/config/__tests__/environment.test.ts

@@ -0,0 +1,49 @@
+import { GlintEnvironment } from '../src';
+
+describe('Environments', () => {
+  describe('moduleMayHaveTagImports', () => {
+    test('locating a single tag', () => {
+      let env = new GlintEnvironment({
+        tags: {
+          'my-cool-environment': { hbs: { typesSource: 'whatever' } },
+        },
+      });
+
+      expect(env.moduleMayHaveTagImports('import foo from "my-cool-environment"\n')).toBe(true);
+    });
+
+    test('locating one of several tags', () => {
+      let env = new GlintEnvironment({
+        tags: {
+          'my-cool-environment': { hbs: { typesSource: 'whatever' } },
+          'another-env': { tagMe: { typesSource: 'over-here' } },
+          'and-this-one': { hbs: { typesSource: '✨' } },
+        },
+      });
+
+      expect(env.moduleMayHaveTagImports('import foo from "another-env"\n')).toBe(true);
+    });
+
+    test('checking a definitely-unused module', () => {
+      let env = new GlintEnvironment({
+        tags: {
+          'my-cool-environment': { hbs: { typesSource: 'whatever' } },
+        },
+      });
+
+      expect(env.moduleMayHaveTagImports('import { hbs } from "another-env"\n')).toBe(false);
+    });
+  });
+
+  describe('getConfiguredTemplateTags', () => {
+    test('returns the given tag config', () => {
+      let tags = {
+        '@glimmerx/component': { hbs: { typesSource: '@glint/environment-glimmerx/types' } },
+      };
+
+      let env = new GlintEnvironment({ tags });
+
+      expect(env.getConfiguredTemplateTags()).toBe(tags);
+    });
+  });
+});

packages/config/__tests__/include-exclude.test.ts

@@ -1,11 +1,11 @@
-import path from 'path';
 import { GlintConfig } from '../src';
 
 describe('include/exclude configuration', () => {
-  const root = path.resolve('/foo/bar');
+  const root = process.cwd();
+  const environment = 'glimmerx';
 
   describe('defaults', () => {
-    const config = new GlintConfig(root, {});
+    const config = new GlintConfig(root, { environment });
 
     test('includes all .ts files within the root', () => {
       expect(config.includesFile(`${root}/file.ts`)).toBe(true);
@@ -30,34 +30,38 @@ describe('include/exclude configuration', () => {
 
   describe('custom configuration', () => {
     test('include glob', () => {
-      let config = new GlintConfig(root, { include: 'src/**/*.txt' });
+      let config = new GlintConfig(root, { environment, include: 'src/**/*.txt' });
       expect(config.includesFile(`${root}/src/file.txt`)).toBe(true);
       expect(config.includesFile(`${root}/file.txt`)).toBe(false);
       expect(config.includesFile(`${root}/src/index.ts`)).toBe(false);
     });
 
     test('include array', () => {
-      let config = new GlintConfig(root, { include: ['**/*.txt', '**/*.ts'] });
+      let config = new GlintConfig(root, { environment, include: ['**/*.txt', '**/*.ts'] });
       expect(config.includesFile(`${root}/hello/there.txt`)).toBe(true);
       expect(config.includesFile(`${root}/index.ts`)).toBe(true);
       expect(config.includesFile(`${root}/file.js`)).toBe(false);
     });
 
     test('exclude glob', () => {
-      let config = new GlintConfig(root, { exclude: 'dist/**/*.ts' });
+      let config = new GlintConfig(root, { environment, exclude: 'dist/**/*.ts' });
       expect(config.includesFile(`${root}/dist/file.ts`)).toBe(false);
       expect(config.includesFile(`${root}/file.ts`)).toBe(true);
     });
 
     test('exclude array', () => {
-      let config = new GlintConfig(root, { exclude: ['dist/**/*.ts', 'vendor/**/*.ts'] });
+      let config = new GlintConfig(root, {
+        environment,
+        exclude: ['dist/**/*.ts', 'vendor/**/*.ts'],
+      });
       expect(config.includesFile(`${root}/dist/file.ts`)).toBe(false);
       expect(config.includesFile(`${root}/vendor/file.ts`)).toBe(false);
       expect(config.includesFile(`${root}/file.ts`)).toBe(true);
     });
 
     test('excludes override includes', () => {
       let config = new GlintConfig(root, {
+        environment,
         include: 'src/**/*.ts',
         exclude: 'src/**/*.generated.ts',
       });

packages/config/__tests__/load-config.test.ts

@@ -1,35 +1,40 @@
 import os from 'os';
 import fs from 'fs';
-import { loadConfig, normalizePath } from '../src';
+import { loadConfig } from '../src';
+import { normalizePath } from '../src/config';
 
 describe('loadConfig', () => {
   const testDir = `${os.tmpdir()}/glint-config-test-${process.pid}`;
 
   beforeEach(() => {
     fs.rmdirSync(testDir, { recursive: true });
     fs.mkdirSync(testDir);
+    fs.writeFileSync(
+      `${testDir}/local-env.js`,
+      `module.exports = () => ({ tags: { test: true } });\n`
+    );
   });
 
   afterEach(() => {
     fs.rmdirSync(testDir, { recursive: true });
   });
 
-  test('returns a default config if none is found', () => {
-    let config = loadConfig(testDir);
-
-    expect(config.rootDir).toBe(normalizePath(testDir));
-    expect(config.includesFile(`${testDir}/index.ts`)).toBe(true);
-    expect(config.includesFile(__filename)).toBe(false);
+  test('throws an error if no config is found', () => {
+    expect(() => loadConfig(testDir)).toThrow(`Unable to find Glint configuration for ${testDir}`);
   });
 
   test('locating config in a parent directory', () => {
     fs.mkdirSync(`${testDir}/deeply/nested/directory`, { recursive: true });
-    fs.writeFileSync(`${testDir}/.glintrc`, `include: '**/*.root.ts'`);
-    fs.writeFileSync(`${testDir}/deeply/.glintrc`, `include: '**/*.nested.ts'`);
+    fs.writeFileSync(`${testDir}/.glintrc`, `environment: kaboom\ninclude: '**/*.root.ts'`);
+    fs.writeFileSync(
+      `${testDir}/deeply/.glintrc`,
+      `environment: '../local-env'\ninclude: '**/*.nested.ts'`
+    );
 
     let config = loadConfig(`${testDir}/deeply/nested/directory`);
 
     expect(config.rootDir).toBe(normalizePath(`${testDir}/deeply`));
+    expect(config.environment.getConfiguredTemplateTags()).toEqual({ test: true });
     expect(config.includesFile(`${testDir}/deeply/index.ts`)).toBe(false);
     expect(config.includesFile(`${testDir}/deeply/index.root.ts`)).toBe(false);
     expect(config.includesFile(`${testDir}/deeply/index.nested.ts`)).toBe(true);
@@ -47,43 +52,54 @@ describe('loadConfig', () => {
           name: 'my-package',
           private: true,
           glint: {
+            environment: './local-env',
             include: '**/*.from-pkg.ts',
           },
         })
       );
 
       let config = loadConfig(testDir);
 
+      expect(config.environment.getConfiguredTemplateTags()).toEqual({ test: true });
       expect(config.includesFile(`${testDir}/index.ts`)).toBe(false);
       expect(config.includesFile(`${testDir}/index.from-pkg.ts`)).toBe(true);
     });
 
     test('reads config from .glintrc', () => {
-      fs.writeFileSync(`${testDir}/.glintrc`, `include: '**/*.extensionless.ts'`);
+      fs.writeFileSync(
+        `${testDir}/.glintrc`,
+        `environment: './local-env'\ninclude: '**/*.extensionless.ts'`
+      );
 
       let config = loadConfig(testDir);
 
+      expect(config.environment.getConfiguredTemplateTags()).toEqual({ test: true });
       expect(config.includesFile(`${testDir}/index.ts`)).toBe(false);
       expect(config.includesFile(`${testDir}/index.extensionless.ts`)).toBe(true);
     });
 
     test('reads config from .glintrc.js', () => {
-      fs.writeFileSync(`${testDir}/.glintrc.js`, `module.exports = { include: '**/*.jsrc.ts' };`);
+      fs.writeFileSync(
+        `${testDir}/.glintrc.js`,
+        `module.exports = { environment: "./local-env", include: '**/*.jsrc.ts' };`
+      );
 
       let config = loadConfig(testDir);
 
+      expect(config.environment.getConfiguredTemplateTags()).toEqual({ test: true });
       expect(config.includesFile(`${testDir}/index.ts`)).toBe(false);
       expect(config.includesFile(`${testDir}/index.jsrc.ts`)).toBe(true);
     });
 
     test('reads config from glint.config.js', () => {
       fs.writeFileSync(
         `${testDir}/glint.config.js`,
-        `module.exports = { include: '**/*.config.ts' };`
+        `module.exports = { environment: './local-env', include: '**/*.config.ts' };`
       );
 
       let config = loadConfig(testDir);
 
+      expect(config.environment.getConfiguredTemplateTags()).toEqual({ test: true });
       expect(config.includesFile(`${testDir}/index.ts`)).toBe(false);
       expect(config.includesFile(`${testDir}/index.config.ts`)).toBe(true);
     });

packages/config/package.json

@@ -19,11 +19,14 @@
   },
   "dependencies": {
     "cosmiconfig": "^6.0.0",
-    "minimatch": "^3.0.4"
+    "escape-string-regexp": "^4.0.0",
+    "minimatch": "^3.0.4",
+    "resolve": "^1.17.0"
   },
   "devDependencies": {
-    "@types/minimatch": "^3.0.3",
     "@types/jest": "^25.2.1",
+    "@types/minimatch": "^3.0.3",
+    "@types/resolve": "^1.17.1",
     "jest": "^25.4.0",
     "ts-jest": "^25.4.0"
   }