@glint/ember-tsc 1.0.1-unstable.845d5fa

package/lib/volar/script-snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"script-snapshot.d.ts","sourceRoot":"","sources":["../../src/volar/script-snapshot.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE9D;;;;GAIG;AACH,qBAAa,cAAe,YAAW,eAAe;IACjC,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM;IAG/B,cAAc,CAAC,YAAY,EAAE,eAAe,GAAG,eAAe,GAAG,SAAS;IAI1E,SAAS,IAAI,MAAM;IAInB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;CAG5C"}

package/lib/volar/script-snapshot.js

@@ -0,0 +1,24 @@
+/**
+ * @typedef {import('typescript').IScriptSnapshot} IScriptSnapshot
+ */
+/**
+ * A TypeScript compatible script snapshot that wraps a string of text.
+ *
+ * @implements {IScriptSnapshot}
+ */
+export class ScriptSnapshot {
+    constructor(text) {
+        this.text = text;
+    }
+    // Not Implemented
+    getChangeRange(_oldSnapshot) {
+        return undefined;
+    }
+    getLength() {
+        return this.text.length;
+    }
+    getText(start, end) {
+        return this.text.slice(start, end);
+    }
+}
+//# sourceMappingURL=script-snapshot.js.map

package/lib/volar/script-snapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"script-snapshot.js","sourceRoot":"","sources":["../../src/volar/script-snapshot.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;;GAIG;AACH,MAAM,OAAO,cAAc;IACzB,YAAmB,IAAY;QAAZ,SAAI,GAAJ,IAAI,CAAQ;IAAG,CAAC;IAEnC,kBAAkB;IAClB,cAAc,CAAC,YAA6B;QAC1C,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,SAAS;QACP,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;IAC1B,CAAC;IAED,OAAO,CAAC,KAAa,EAAE,GAAW;QAChC,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IACrC,CAAC;CACF"}

package/package.json

@@ -0,0 +1,114 @@
+{
+  "name": "@glint/ember-tsc",
+  "version": "1.0.1-unstable.845d5fa",
+  "repository": "typed-ember/glint",
+  "description": "A CLI for performing typechecking on Glimmer templates",
+  "license": "MIT",
+  "author": "Dan Freeman (https://github.com/dfreeman)",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./config-types": {
+      "types": "./lib/config/types.d.cts",
+      "default": "./lib/config/types.cjs"
+    },
+    "./bin/*": "./bin/*.js",
+    "./globals": "./types/globals/index.d.ts",
+    "./-private/dsl": {
+      "types": "./types/-private/dsl/index.d.ts",
+      "default": "./types/-private/dsl/index.d.ts"
+    },
+    "./types": "./types/-private/dsl/integration-declarations.d.ts",
+    "./-private/dsl/globals": "./types/-private/dsl/globals.d.ts",
+    "./-private/intrinsics/action": "./types/-private/intrinsics/action.d.ts",
+    "./-private/intrinsics/concat": "./types/-private/intrinsics/concat.d.ts",
+    "./-private/intrinsics/each": "./types/-private/intrinsics/each.d.ts",
+    "./-private/intrinsics/each-in": "./types/-private/intrinsics/each-in.d.ts",
+    "./-private/intrinsics/fn": "./types/-private/intrinsics/fn.d.ts",
+    "./-private/intrinsics/get": "./types/-private/intrinsics/get.d.ts",
+    "./-private/intrinsics/log": "./types/-private/intrinsics/log.d.ts",
+    "./-private/intrinsics/mount": "./types/-private/intrinsics/mount.d.ts",
+    "./-private/intrinsics/mut": "./types/-private/intrinsics/mut.d.ts",
+    "./-private/intrinsics/on": "./types/-private/intrinsics/on.d.ts",
+    "./-private/intrinsics/outlet": "./types/-private/intrinsics/outlet.d.ts",
+    "./-private/intrinsics/unbound": "./types/-private/intrinsics/unbound.d.ts",
+    "./-private/intrinsics/unique-id": "./types/-private/intrinsics/unique-id.d.ts",
+    "./*": {
+      "types": "./lib/*.d.ts",
+      "default": "./lib/*.js"
+    }
+  },
+  "files": [
+    "README.md",
+    "lib",
+    "bin",
+    "src",
+    "types"
+  ],
+  "bin": {
+    "glint": "bin/glint.js",
+    "glint-language-server": "bin/glint-language-server.js"
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "dev": "tsc --watch",
+    "prepack": "pnpm build"
+  },
+  "release-plan": {
+    "semverIncrementAs": {
+      "major": "prerelease",
+      "minor": "prerelease",
+      "patch": "prerelease"
+    },
+    "semverIncrementTag": "alpha",
+    "publishTag": "alpha"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.6.0"
+  },
+  "dependencies": {
+    "@glimmer/syntax": ">= 0.95.0",
+    "@glint/template": "1.6.1-unstable.845d5fa",
+    "@volar/kit": "2.4.23",
+    "@volar/language-core": "2.4.23",
+    "@volar/language-server": "2.4.23",
+    "@volar/language-service": "2.4.23",
+    "@volar/source-map": "2.4.23",
+    "@volar/test-utils": "2.4.23",
+    "@volar/typescript": "2.4.23",
+    "computeds": "^0.0.1",
+    "content-tag": "^3.1.2",
+    "escape-string-regexp": "^4.0.0",
+    "semver": "^7.5.2",
+    "silent-error": "^1.1.1",
+    "uuid": "^8.3.2",
+    "volar-service-typescript": "volar-2.4",
+    "volar-service-html": "volar-2.4",
+    "vscode-languageserver-protocol": "^3.17.5",
+    "vscode-languageserver-textdocument": "^1.0.5",
+    "vscode-uri": "^3.0.8",
+    "yargs": "^17.5.1"
+  },
+  "devDependencies": {
+    "@glimmer/component": "^2.0.0",
+    "@glint/type-test": "2.0.1-unstable.845d5fa",
+    "@types/common-tags": "^1.8.0",
+    "@types/node": "^18.11.5",
+    "@types/semver": "^7.3.13",
+    "@types/uuid": "^8.3.4",
+    "@types/yargs": "^17.0.10",
+    "@typescript/server-harness": "latest",
+    "@vitest/ui": "~1.0.0",
+    "common-tags": "^1.8.0",
+    "execa": "^4.0.1",
+    "glint-monorepo-test-utils": "workspace:*",
+    "strip-ansi": "^6.0.0",
+    "typescript": ">=5.6.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/cli/run-volar-tsc.ts

@@ -0,0 +1,36 @@
+import { runTsc } from '@volar/typescript/lib/quickstart/runTsc.js';
+import { createEmberLanguagePlugin } from '../volar/ember-language-plugin.js';
+import { findConfig } from '../config/index.js';
+
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+
+export function run(): void {
+  let cwd = process.cwd();
+
+  const options = {
+    extraSupportedExtensions: ['.gjs', '.gts'],
+
+    extraExtensionsToRemove: [],
+
+    // With the above configuration, `{basename}.gts` will produce `{basename}.gts.d.ts`.
+    // If we would prefer `{basename}.d.ts`, we could use the following configuration instead:
+    //
+    // extraExtensionsToRemove: ['.gts', '.gjs'],
+    //
+    // See discussion here: https://github.com/typed-ember/glint/issues/628
+  };
+
+  const main = (): void =>
+    runTsc(require.resolve('typescript/lib/tsc'), options, (ts, options) => {
+      const glintConfig = findConfig(cwd);
+
+      if (glintConfig) {
+        const gtsLanguagePlugin = createEmberLanguagePlugin(glintConfig);
+        return [gtsLanguagePlugin];
+      } else {
+        return [];
+      }
+    });
+  main();
+}

package/src/config/config.ts

@@ -0,0 +1,33 @@
+import { GlintConfigInput } from '@glint/ember-tsc/config-types';
+import * as path from 'node:path';
+import { GlintEnvironment } from './environment.js';
+
+/**
+ * This class represents parsed Glint configuration from a `tsconfig` or `jsconfig` file,
+ * with methods for interrogating project configuration based on its contents.
+ */
+export class GlintConfig {
+  declare public readonly ts: typeof import('typescript');
+  public readonly rootDir: string;
+  public readonly configPath: string;
+  public readonly environment: GlintEnvironment;
+
+  public constructor(
+    ts: typeof import('typescript'),
+    configPath: string,
+    config: GlintConfigInput,
+  ) {
+    Object.defineProperty(this, 'ts', { value: ts });
+    this.configPath = normalizePath(configPath);
+    this.rootDir = path.dirname(configPath);
+    this.environment = GlintEnvironment.load(config);
+  }
+}
+
+export function normalizePath(fileName: string): string {
+  if (path.sep !== '/') {
+    return fileName.split(path.sep).join('/');
+  }
+
+  return fileName;
+}

package/src/config/environment.ts

@@ -0,0 +1,128 @@
+import {
+  GlintEnvironmentConfig,
+  GlintExtensionConfig,
+  GlintExtensionsConfig,
+  GlintTagsConfig,
+  SourceKind,
+} from '@glint/ember-tsc/config-types';
+import * as path from 'node:path';
+import SilentError from 'silent-error';
+
+import emberTemplateImportsEnvironment from '../environment-ember-template-imports/-private/environment/index.js';
+
+export const DEFAULT_EXTENSIONS: GlintExtensionsConfig = {
+  '.js': { kind: 'untyped-script' },
+  '.ts': { kind: 'typed-script' },
+};
+
+/**
+ * A GlintEnvironment represents the _merged_ configurations of one or more
+ * glint environments (e.g. ember-template-imports).
+ */
+export class GlintEnvironment {
+  private tagConfig: GlintTagsConfig;
+  private extensionsConfig: GlintExtensionsConfig;
+
+  public constructor(
+    public readonly names: Array<string>,
+    config: GlintEnvironmentConfig,
+  ) {
+    this.tagConfig = config.tags ?? {};
+    // when is this populated? what is config?
+    this.extensionsConfig = config.extensions ?? {};
+  }
+
+  public static load(topLevelGlintConfigObject: any): GlintEnvironment {
+    // Glint V1:
+    let additionalGlobals = null;
+    let additionalSpecialForms = {};
+    if (topLevelGlintConfigObject) {
+      if (
+        topLevelGlintConfigObject.additionalGlobals ||
+        topLevelGlintConfigObject.additionalSpecialForms
+      ) {
+        additionalGlobals = topLevelGlintConfigObject.additionalGlobals;
+        additionalSpecialForms = topLevelGlintConfigObject.additionalSpecialForms ?? {};
+      } else {
+        if (Array.isArray(topLevelGlintConfigObject.environment)) {
+          // If it's a legacy array of environment names, e.g. ['ember-template-imports', 'ember-loose'],
+          // then there is no additional config such as additionalGlobals to extract.
+        } else {
+          if (typeof topLevelGlintConfigObject.environment === 'object') {
+            const emberTemplateImportsConfig =
+              topLevelGlintConfigObject.environment?.['ember-template-imports'] ?? {};
+            additionalGlobals = emberTemplateImportsConfig.additionalGlobals ?? [];
+            additionalSpecialForms = emberTemplateImportsConfig.additionalSpecialForms ?? {};
+          }
+        }
+      }
+    }
+
+    let tags: GlintTagsConfig = {};
+    let extensions: GlintExtensionsConfig = { ...DEFAULT_EXTENSIONS };
+
+    const envUserConfig = { additionalGlobals, additionalSpecialForms };
+
+    let config = emberTemplateImportsEnvironment(envUserConfig) as GlintEnvironmentConfig;
+
+    if (config.tags) {
+      for (let [importSource, specifiers] of Object.entries(config.tags)) {
+        tags[importSource] ??= {};
+        for (let [importSpecifier, tagConfig] of Object.entries(specifiers)) {
+          if (importSpecifier in tags[importSource]) {
+            throw new SilentError(
+              'Multiple configured Glint environments attempted to define behavior for the tag `' +
+                importSpecifier +
+                "` in module '" +
+                importSource +
+                "'.",
+            );
+          }
+
+          tags[importSource][importSpecifier] = tagConfig;
+        }
+      }
+    }
+
+    if (config.extensions) {
+      for (let [extension, extensionConfig] of Object.entries(config.extensions)) {
+        if (extension in extensions) {
+          throw new SilentError(
+            'Multiple configured Glint environments attempted to define handling for the ' +
+              extension +
+              ' file extension.',
+          );
+        }
+
+        extensions[extension] = extensionConfig;
+      }
+    }
+
+    return new GlintEnvironment(Object.keys(config), { tags, extensions });
+  }
+
+  public getSourceKind(fileName: string): SourceKind | 'unknown' {
+    let extension = path.extname(fileName);
+    return this.extensionsConfig[extension]?.kind ?? 'unknown';
+  }
+
+  public isUntypedScript(path: string): boolean {
+    return this.getSourceKind(path) === 'untyped-script';
+  }
+
+  /**
+   * Returns any custom configuration for the given file extension.
+   */
+  public getConfigForExtension(extension: string): GlintExtensionConfig | undefined {
+    return this.extensionsConfig[extension];
+  }
+
+  /**
+   * Returns an array of template tags that should be rewritten according to this
+   * config object, along with an import specifier indicating where the template types
+   * for each tag can be found.
+   */
+  public getConfiguredTemplateTags(): GlintTagsConfig {
+    return this.tagConfig;
+  }
+}

package/src/config/index.ts

@@ -0,0 +1,30 @@
+import SilentError from 'silent-error';
+import { GlintConfig } from './config.js';
+import { ConfigLoader } from './loader.js';
+
+export { GlintConfig } from './config.js';
+export { GlintEnvironment } from './environment.js';
+export { ConfigLoader, findTypeScript } from './loader.js';
+
+/**
+ * Loads glint configuration, starting from the given directory
+ * and searching upwards and raising an error if no configuration
+ * is found.
+ */
+export function loadConfig(from: string): GlintConfig {
+  let config = findConfig(from);
+  if (!config) {
+    throw new SilentError(`Unable to find Glint configuration for ${from}`);
+  }
+
+  return config;
+}
+
+/**
+ * Loads glint configuration, starting from the given directory
+ * and searching upwards. Returns `null` if no configuration is
+ * found.
+ */
+export function findConfig(from: string): GlintConfig | null {
+  return new ConfigLoader().configForDirectory(from);
+}

package/src/config/loader.ts

@@ -0,0 +1,143 @@
+import { GlintConfigInput } from '@glint/ember-tsc/config-types';
+import * as fs from 'node:fs';
+import { createRequire } from 'node:module';
+import * as path from 'node:path';
+import SilentError from 'silent-error';
+import type TS from 'typescript';
+import { GlintConfig } from './config.js';
+
+/**
+ * @private
+ *
+ * Only exported for testing purposes. Do not import.
+ */
+export const require = createRequire(import.meta.url);
+
+type TypeScript = typeof TS;
+
+/**
+ * `ConfigLoader` provides an interface for finding the Glint config that
+ * applies to a given file or directory, ensuring that only a single instance
+ * of `GlintConfig` is ever created for a given `tsconfig.json` or
+ * `jsconfig.json` source file.
+ */
+export class ConfigLoader {
+  private configs = new Map<string, GlintConfig | null>();
+
+  public configForFile(filePath: string): GlintConfig | null {
+    return this.configForDirectory(path.dirname(filePath));
+  }
+
+  public configForDirectory(directory: string): GlintConfig | null {
+    let ts = findTypeScript(directory);
+    if (!ts) return null;
+
+    let configPath = findNearestConfigFile(ts, directory);
+    if (!configPath) return null;
+
+    let existing = this.configs.get(configPath);
+    if (existing !== undefined) return existing;
+
+    let configInput = loadConfigInput(ts, configPath);
+    let config = new GlintConfig(ts, configPath, configInput || { environment: [] });
+
+    this.configs.set(configPath, config);
+
+    return config;
+  }
+}
+
+export function findTypeScript(fromDir: string): TypeScript | null {
+  let requireFrom = path.resolve(fromDir, 'package.json');
+  return (
+    tryResolve(() => createRequire(requireFrom)('typescript')) ??
+    tryResolve(() => require('typescript'))
+  );
+}
+
+function tryResolve<T>(load: () => T): T | null {
+  try {
+    return load();
+  } catch (error: any) {
+    if (error?.code === 'MODULE_NOT_FOUND') {
+      return null;
+    }
+
+    throw error;
+  }
+}
+
+function parseConfigInput(
+  ts: TypeScript,
+  entryPath: string,
+  currentPath: string,
+  fullGlintConfig: Record<string, unknown>,
+): Record<string, unknown> {
+  let currentContents: any = ts.readConfigFile(currentPath, ts.sys.readFile).config;
+  let currentGlintConfig = currentContents.glint ?? {};
+
+  assert(
+    currentPath === entryPath || !currentGlintConfig.transform,
+    'Glint `transform` options may not be specified in extended config.',
+  );
+
+  if (currentContents.extends) {
+    let paths: string[] = Array.isArray(currentContents.extends)
+      ? currentContents.extends
+      : [currentContents.extends];
+    for (let extendPath of paths) {
+      let currentExtendPath = path.resolve(path.dirname(currentPath), extendPath);
+      if (!fs.existsSync(currentExtendPath)) {
+        try {
+          currentExtendPath = require.resolve(currentContents.extends);
+        } catch {
+          // suppress the exception thrown by require.resolve for those scenarios where the file does not exist
+        }
+      }
+
+      fullGlintConfig = parseConfigInput(ts, entryPath, currentExtendPath, fullGlintConfig);
+    }
+  }
+
+  return { ...fullGlintConfig, ...currentGlintConfig };
+}
+
+export function loadConfigInput(ts: TypeScript, entryPath: string): GlintConfigInput | null {
+  return validateConfigInput(parseConfigInput(ts, entryPath, entryPath, {}));
+}
+
+function findNearestConfigFile(ts: TypeScript, searchFrom: string): string {
+  // Assume that the longest path is the most relevant one in the case that
+  // multiple config files exist at or above our current directory.
+  let configCandidates = [
+    ts.findConfigFile(searchFrom, ts.sys.fileExists, 'tsconfig.json'),
+    ts.findConfigFile(searchFrom, ts.sys.fileExists, 'jsconfig.json'),
+  ]
+    .filter((path): path is string => typeof path === 'string')
+    .sort((a, b) => b.length - a.length);
+
+  return configCandidates[0];
+}
+
+function validateConfigInput(input: Record<string, unknown>): GlintConfigInput | null {
+  if (!input['environment']) {
+    input['environment'] = [];
+  }
+
+  assert(
+    Array.isArray(input['environment'])
+      ? input['environment'].every((env) => typeof env === 'string')
+      : typeof input['environment'] === 'string' ||
+          (typeof input['environment'] === 'object' && input['environment']),
+    'Glint config must specify an `environment` that is a string, array of strings, or an object ' +
+      'mapping environment names to their config.',
+  );
+
+  return input as GlintConfigInput;
+}
+
+function assert(test: unknown, message: string): asserts test {
+  if (!test) {
+    throw new SilentError(`Glint config: ${message}`);
+  }
+}

package/src/config/types.cts

@@ -0,0 +1,85 @@
+import type ts from 'typescript';
+
+// This file is explicitly `.cts` so that environment packages written
+// in CJS can import its types from `@glint/ember-tsc/config-types`.
+
+type TSLib = typeof ts;
+
+export type GlintConfigInput = {
+  environment: string | Array<string> | Record<string, unknown>;
+};
+
+export type GlintEnvironmentConfig = {
+  tags?: GlintTagsConfig;
+  extensions?: GlintExtensionsConfig;
+};
+
+export type GlintExtensionPreprocess<T> = (
+  source: string,
+  filePath: string,
+) => { contents: string; data?: T };
+
+export type GlintEmitMetadata = {
+  prepend?: string;
+  append?: string;
+  templateLocation?: {
+    start: number;
+    end: number;
+    contentStart: number;
+    contentEnd: number;
+  };
+};
+
+export type GlintExtensionTransform<T> = (
+  data: T,
+  state: {
+    ts: TSLib;
+    context: ts.TransformationContext;
+    setEmitMetadata: (node: ts.TaggedTemplateExpression, meta: GlintEmitMetadata) => void;
+  },
+) => ts.Transformer<ts.Node>;
+
+export type GlintSpecialForm =
+  | 'if'
+  | 'if-not'
+  | 'yield'
+  | 'object-literal'
+  | 'array-literal'
+  | 'bind-invokable'
+  | '==='
+  | '!=='
+  | '&&'
+  | '||'
+  | '!';
+
+export type GlintSpecialFormConfig = {
+  globals?: { [global: string]: GlintSpecialForm };
+  imports?: {
+    [path: string]: {
+      [identifier: string]: GlintSpecialForm;
+    };
+  };
+};
+
+export type SourceKind = 'typed-script' | 'untyped-script';
+export type GlintExtensionConfig<PreprocessData = any> = {
+  kind: SourceKind;
+  preprocess?: GlintExtensionPreprocess<PreprocessData>;
+  transform?: GlintExtensionTransform<PreprocessData>;
+};
+
+export type GlintExtensionsConfig = {
+  [extension: string]: GlintExtensionConfig;
+};
+
+export type GlintTagConfig = {
+  typesModule: string;
+  globals?: Array<string>;
+  specialForms?: GlintSpecialFormConfig;
+};
+
+export type GlintTagsConfig = {
+  [importSource: string]: {
+    [importSpecifier: string]: GlintTagConfig;
+  };
+};

package/src/environment-ember-template-imports/-private/environment/common.ts

@@ -0,0 +1,14 @@
+export type PreprocessData = {
+  templateLocations: Array<TemplateLocation>;
+};
+
+export type TemplateLocation = {
+  startTagOffset: number;
+  startTagLength: number;
+  endTagOffset: number;
+  endTagLength: number;
+  transformedStart: number;
+  transformedEnd: number;
+};
+
+export const GLOBAL_TAG = `___T`;