@glint/ember-tsc 1.4.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glint/ember-tsc",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "repository": "typed-ember/glint",
   "description": "A CLI for performing typechecking on Glimmer templates",
   "license": "MIT",
@@ -24,9 +24,12 @@
     "./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/array-hash": "./types/-private/intrinsics/array-hash.d.ts",
+    "./-private/intrinsics/comparison": "./types/-private/intrinsics/comparison.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/element": "./types/-private/intrinsics/element.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",
@@ -34,6 +37,8 @@
     "./-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/truth-convert": "./types/-private/intrinsics/truth-convert.d.ts",
+    "./-private/intrinsics/truth-helpers": "./types/-private/intrinsics/truth-helpers.d.ts",
     "./-private/intrinsics/unbound": "./types/-private/intrinsics/unbound.d.ts",
     "./-private/intrinsics/unique-id": "./types/-private/intrinsics/unique-id.d.ts",
     "./*": {
@@ -53,8 +58,14 @@
     "glint-language-server": "bin/glint-language-server.js"
   },
   "peerDependencies": {
+    "ember-source": ">=7.1.0",
     "typescript": ">=5.6.0"
   },
+  "peerDependenciesMeta": {
+    "ember-source": {
+      "optional": true
+    }
+  },
   "dependencies": {
     "@glimmer/syntax": "^0.95.0",
     "@volar/kit": "~2.4.28",
@@ -86,8 +97,8 @@
     "execa": "^4.0.1",
     "strip-ansi": "^6.0.0",
     "typescript": "^5.9.3",
-    "@glint/type-test": "2.0.1",
-    "glint-monorepo-test-utils": "0.0.0"
+    "glint-monorepo-test-utils": "0.0.0",
+    "@glint/type-test": "2.0.1"
   },
   "publishConfig": {
     "access": "public"

package/src/config/index.ts

@@ -1,4 +1,6 @@
+import * as path from 'node:path';
 import SilentError from 'silent-error';
+import type TS from 'typescript';
 import { GlintConfig } from './config.js';
 import { ConfigLoader } from './loader.js';
 
@@ -28,3 +30,13 @@ export function loadConfig(from: string): GlintConfig {
 export function findConfig(from: string): GlintConfig | null {
   return new ConfigLoader().configForDirectory(from);
 }
+
+/**
+ * Creates a default GlintConfig with ember-template-imports environment
+ * for use when no tsconfig.json or jsconfig.json exists. This enables
+ * Glint to provide IntelliSense in JavaScript-only Ember projects.
+ */
+export function createDefaultConfig(ts: typeof TS, rootDir: string): GlintConfig {
+  const syntheticConfigPath = path.join(rootDir, 'jsconfig.json');
+  return new GlintConfig(ts, syntheticConfigPath, { environment: 'ember-template-imports' });
+}

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

@@ -16,6 +16,52 @@ export default function emberTemplateImportsEnvironment(
     ? options['additionalGlobals']
     : [];
 
+  const globalsForEmber = [
+    'action',
+    'component',
+    'debugger',
+    'each',
+    'each-in',
+    'has-block',
+    'has-block-params',
+    'helper',
+    'if',
+    'in-element',
+    'let',
+    'log',
+    'modifier',
+    'mount',
+    'mut',
+    'outlet',
+    'unbound',
+    'unless',
+    'with',
+    'yield',
+  ];
+
+  /*
+    Ember 7.1+ built-in keywords (RFCs 389, 470, 560, 561, 562, 997, 998, 999,
+    1000). Their template-side signatures live in `KeywordsForEmber71` in
+    `types/-private/dsl/globals.d.ts` and are gated on `ember-source >= 7.1.0`
+    via the `HasEmber71BuiltIns` probe.
+  */
+  const globalsForEmber71 = [
+    'and',
+    'array',
+    'element',
+    'eq',
+    'fn',
+    'gt',
+    'gte',
+    'hash',
+    'lt',
+    'lte',
+    'neq',
+    'not',
+    'on',
+    'or',
+  ];
+
   return {
     tags: {
       '@glint/ember-tsc/environment-ember-template-imports/-private/tag': {
@@ -41,26 +87,8 @@ export default function emberTemplateImportsEnvironment(
             },
           },
           globals: [
-            'action',
-            'component',
-            'debugger',
-            'each',
-            'each-in',
-            'has-block',
-            'has-block-params',
-            'helper',
-            'if',
-            'in-element',
-            'let',
-            'log',
-            'modifier',
-            'mount',
-            'mut',
-            'outlet',
-            'unbound',
-            'unless',
-            'with',
-            'yield',
+            ...globalsForEmber,
+            ...globalsForEmber71,
             ...Object.keys(additionalGlobalSpecialForms),
             ...additionalGlobals,
           ],

package/src/index.ts

@@ -1,9 +1,16 @@
-import { GlintConfig, loadConfig, findConfig } from './config/index.js';
+import { GlintConfig, loadConfig, findConfig, createDefaultConfig } from './config/index.js';
 import { createEmberLanguagePlugin } from './volar/ember-language-plugin.js';
 
 import { VirtualGtsCode } from './volar/gts-virtual-code.js';
 import { augmentDiagnostics } from './transform/diagnostics/augmentation.js';
 
-export { loadConfig, findConfig, createEmberLanguagePlugin, VirtualGtsCode, augmentDiagnostics };
+export {
+  loadConfig,
+  findConfig,
+  createDefaultConfig,
+  createEmberLanguagePlugin,
+  VirtualGtsCode,
+  augmentDiagnostics,
+};
 
 export type { GlintConfig };

package/src/volar/language-server.ts

@@ -1,3 +1,4 @@
+import * as path from 'node:path';
 import { createLanguage } from '@volar/language-core';
 import type { LanguagePlugin, LanguageServer } from '@volar/language-server';
 import { createLanguageServiceEnvironment } from '@volar/language-server/lib/project/simpleProject.js';
@@ -9,6 +10,7 @@ import { create as createHtmlSyntacticPlugin } from 'volar-service-html';
 import { create as createTypeScriptSyntacticPlugin } from 'volar-service-typescript/lib/plugins/syntactic.js';
 import { URI } from 'vscode-uri';
 import { ConfigLoader } from '../config/loader.js';
+import { createDefaultConfig } from '../config/index.js';
 import { create as createCompilerErrorsPlugin } from '../plugins/g-compiler-errors.js';
 import { create as createComponentHoverPlugin } from '../plugins/g-component-hover.js';
 import type { ComponentMeta, TsPluginClient } from '../plugins/g-component-hover.js';
@@ -143,18 +145,28 @@ connection.onInitialize((params) => {
       },
     ];
 
-    if (tsconfigFileName) {
-      const configLoader = new ConfigLoader(logInfo);
-      const glintConfig = configLoader.configForFile(tsconfigFileName);
-      if (glintConfig) {
-        logInfo(`Glint config active for ${tsconfigFileName}.`);
-        const emberLanguagePlugin = createEmberLanguagePlugin(glintConfig);
-        languagePlugins.push(emberLanguagePlugin);
-      } else {
-        logWarn(`Glint config not found for ${tsconfigFileName}; Glint features disabled.`);
+    {
+      let glintConfig = null;
+      const isRealConfigFile =
+        tsconfigFileName &&
+        !tsconfigFileName.startsWith('/dev/null') &&
+        tsconfigFileName.endsWith('.json');
+      if (isRealConfigFile) {
+        const configLoader = new ConfigLoader(logInfo);
+        glintConfig = configLoader.configForFile(tsconfigFileName);
+      }
+      if (!glintConfig) {
+        const rootDir = isRealConfigFile
+          ? path.dirname(tsconfigFileName!)
+          : params.workspaceFolders?.[0]
+            ? URI.parse(params.workspaceFolders[0].uri).fsPath
+            : process.cwd();
+        logInfo(`Using default Glint config for ${rootDir}.`);
+        glintConfig = createDefaultConfig(ts, rootDir);
       }
-    } else {
-      logWarn('No tsconfig/jsconfig provided; Glint config cannot be resolved.');
+      logInfo(`Glint config active for ${tsconfigFileName ?? 'default'}.`);
+      const emberLanguagePlugin = createEmberLanguagePlugin(glintConfig);
+      languagePlugins.push(emberLanguagePlugin);
     }
 
     const language = createLanguage<URI>(languagePlugins, createUriMap(), (uri) => {

package/types/-private/dsl/globals.d.ts

@@ -3,19 +3,59 @@ import Globals from '../../globals';
 import * as VM from '@glint/template/-private/keywords';
 
 import { ActionKeyword } from '../intrinsics/action';
+import { ArrayHelper, HashHelper } from '../intrinsics/array-hash';
+import {
+  EqHelper,
+  GtHelper,
+  GteHelper,
+  LtHelper,
+  LteHelper,
+  NeqHelper,
+} from '../intrinsics/comparison';
 import { EachKeyword } from '../intrinsics/each';
 import { EachInKeyword } from '../intrinsics/each-in';
+import { ElementHelper } from '../intrinsics/element';
+import { FnHelper } from '../intrinsics/fn';
 import { LogHelper } from '../intrinsics/log';
 import { MountKeyword } from '../intrinsics/mount';
 import { MutKeyword } from '../intrinsics/mut';
+import { OnModifier } from '../intrinsics/on';
 import { OutletKeyword } from '../intrinsics/outlet';
+import { AndHelper, NotHelper, OrHelper } from '../intrinsics/truth-helpers';
 import { UnboundKeyword } from '../intrinsics/unbound';
 import { UniqueIdHelper } from '../intrinsics/unique-id';
 
+// ---- ember-source 7.1 detection -------------------------------------------
+//
+// The keywords introduced by RFCs 562, 470, 997, 998, 999, 1000, 560, 561 and
+// 389 are only available at runtime when consumers are on ember-source >= 7.1.
+// We probe for the `eq` value re-export added by RFC 561 to decide whether to
+// expose the new keyword types. On older versions the probe collapses to the
+// empty type, so referencing e.g. `{{eq}}` falls back to whatever the user
+// has imported (or surfaces as an "unknown identifier" diagnostic), keeping
+// behaviour identical to today.
+//
+// We probe a value export (`eq`) rather than the matching `EqHelper`
+// interface because `typeof import(...)` only surfaces the module's value
+// exports; type-only exports never appear as keys, so an interface probe
+// would always collapse to `false`.
+//
+// `@ember/helper` is an optional peer dependency at the type level: the
+// `@ts-ignore` ensures Glint still type-checks in environments that haven't
+// installed it.
+//
+// @ts-ignore — `@ember/helper` is an optional peer dependency
+type EmberHelperExports = typeof import('@ember/helper');
+
+type HasEmber71BuiltIns = [EmberHelperExports] extends [{ eq: unknown }] ? true : false;
+
+/** Resolves to `T` only when ember-source >= 7.1 ships the new keyword set. */
+type Ember71Only<T> = HasEmber71BuiltIns extends true ? T : never;
+
 // The keyword vs global breakdown here is loosely matched with
 // the listing in http://emberjs.github.io/rfcs/0496-handlebars-strict-mode.html
 
-interface Keywords {
+interface KeywordsForEmber {
   /**
     The {{action}} helper provides a way to pass triggers for behavior (usually just a function)
     between components, and into components from controllers.
@@ -201,4 +241,279 @@ interface Keywords {
   yield: void;
 }
 
+/**
+ * Built-in template keywords introduced by ember-source 7.1
+ * (RFCs 389, 470, 560, 561, 562, 997, 998, 999, 1000). Each entry is gated by
+ * `Ember71Only<T>` so the keyword resolves to `never` (and is therefore
+ * effectively absent) when the consumer is on ember-source < 7.1. See the
+ * `HasEmber71BuiltIns` probe at the top of this file.
+ */
+interface KeywordsForEmber71 {
+  /**
+   * The `{{and}}` helper evaluates arguments left to right, returning the first
+   * falsy value (using Handlebars truthiness) or the right-most value if all
+   * are truthy. Requires at least two arguments.
+   *
+   * ```gjs
+   * <template>
+   *   {{if (and @isAdmin @isLoggedIn) "Welcome, admin!" "Access denied"}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `and` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/and
+   */
+  and: Ember71Only<AndHelper>;
+
+  /**
+   * Using the `{{array}}` helper, you can pass arrays directly from the
+   * template as an argument to your components.
+   *
+   * ```gjs
+   * <template>
+   *   <ul>
+   *     {{#each (array "Tom Dale" "Yehuda Katz" @anotherPerson) as |person|}}
+   *       <li>{{person}}</li>
+   *     {{/each}}
+   *   </ul>
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `array` is available as a
+   * keyword and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/array
+   */
+  array: Ember71Only<ArrayHelper>;
+
+  /**
+   * The `{{element}}` helper lets you dynamically set the tag name of an
+   * element.
+   *
+   * ```gjs
+   * <template>
+   *   {{#let (element @tagName) as |Tag|}}
+   *     <Tag class="my-element">Hello</Tag>
+   *   {{/let}}
+   * </template>
+   * ```
+   *
+   * When `@tagName` is `"h1"`, this renders `<h1 class="my-element">Hello</h1>`.
+   * When `@tagName` is an empty string, the block content is rendered without
+   * a wrapping element. When `@tagName` is `null` or `undefined`, nothing is
+   * rendered.
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `element` is available as a
+   * keyword and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/element
+   */
+  element: Ember71Only<ElementHelper>;
+
+  /**
+   * The `{{eq}}` helper returns `true` if its two arguments are strictly equal
+   * (`===`). Takes exactly two arguments.
+   *
+   * ```gjs
+   * <template>
+   *   {{if (eq @status "active") "Active" "Inactive"}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `eq` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/eq
+   */
+  eq: Ember71Only<EqHelper>;
+
+  /**
+   * `{{fn}}` is a helper that receives a function and some arguments, and
+   * returns a new function that combines them. This allows you to pass
+   * parameters along to functions in your templates:
+   *
+   * ```gjs
+   * function showAlert(message) {
+   *   alert(`The message is: '${message}'`);
+   * }
+   *
+   * <template>
+   *   <button type="button" {{on "click" (fn showAlert "Hello!")}}>
+   *     Click me!
+   *   </button>
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `fn` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/fn
+   */
+  fn: Ember71Only<FnHelper>;
+
+  /**
+   * The `{{gt}}` helper returns `true` if the first argument is greater than
+   * the second argument.
+   *
+   * ```gjs
+   * <template>
+   *   {{if (gt @score 100) "High score!" "Keep trying"}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `gt` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/gt
+   */
+  gt: Ember71Only<GtHelper>;
+
+  /**
+   * The `{{gte}}` helper returns `true` if the first argument is greater than
+   * or equal to the second argument.
+   *
+   * ```gjs
+   * <template>
+   *   {{if (gte @age 18) "Adult" "Minor"}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `gte` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/gte
+   */
+  gte: Ember71Only<GteHelper>;
+
+  /**
+   * Using the `{{hash}}` helper, you can pass objects directly from the
+   * template as an argument to your components.
+   *
+   * ```gjs
+   * <template>
+   *   {{#each-in (hash givenName="Jen" familyName="Weber") as |key value|}}
+   *     <p>{{key}}: {{value}}</p>
+   *   {{/each-in}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `hash` is available as a
+   * keyword and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/hash
+   */
+  hash: Ember71Only<HashHelper>;
+
+  /**
+   * The `{{lt}}` helper returns `true` if the first argument is less than the
+   * second argument.
+   *
+   * ```gjs
+   * <template>
+   *   {{if (lt @temperature 0) "Freezing" "Above zero"}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `lt` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/lt
+   */
+  lt: Ember71Only<LtHelper>;
+
+  /**
+   * The `{{lte}}` helper returns `true` if the first argument is less than or
+   * equal to the second argument.
+   *
+   * ```gjs
+   * <template>
+   *   {{if (lte @count 0) "Empty" "Has items"}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `lte` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/lte
+   */
+  lte: Ember71Only<LteHelper>;
+
+  /**
+   * The `{{neq}}` helper returns `true` if its two arguments are strictly not
+   * equal (`!==`). Takes exactly two arguments.
+   *
+   * ```gjs
+   * <template>
+   *   {{if (neq @status "active") "Not active" "Active"}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `neq` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/neq
+   */
+  neq: Ember71Only<NeqHelper>;
+
+  /**
+   * The `{{not}}` helper returns the logical negation of its argument using
+   * Handlebars truthiness. Takes exactly one argument.
+   *
+   * ```gjs
+   * <template>
+   *   {{if (not @isDisabled) "Enabled" "Disabled"}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `not` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/not
+   */
+  not: Ember71Only<NotHelper>;
+
+  /**
+   * The `{{on}}` element modifier attaches an event listener to an element.
+   *
+   * ```gjs
+   * <template>
+   *   <button type="button" {{on "click" this.handleClick}}>
+   *     Click me!
+   *   </button>
+   * </template>
+   * ```
+   *
+   * It accepts the same options as `addEventListener` via named arguments
+   * (`capture`, `once`, `passive`).
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `on` is available as a keyword
+   * and does not need to be imported from `@ember/modifier`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fmodifier/on
+   */
+  on: Ember71Only<OnModifier>;
+
+  /**
+   * The `{{or}}` helper evaluates arguments left to right, returning the first
+   * truthy value (using Handlebars truthiness) or the right-most value if all
+   * are falsy. Requires at least two arguments.
+   *
+   * ```gjs
+   * <template>
+   *   {{if (or @hasAccess @isAdmin) "Welcome!" "No access"}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `or` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/or
+   */
+  or: Ember71Only<OrHelper>;
+}
+
+interface Keywords extends KeywordsForEmber, KeywordsForEmber71 {}
+
 export const Globals: Keywords & Globals;

package/types/-private/intrinsics/array-hash.d.ts

@@ -0,0 +1,17 @@
+import { DirectInvokable } from '@glint/template/-private/integration';
+
+/**
+ * `(array a b ...)` — packs the positional arguments into a typed tuple.
+ * Built-in keyword in ember-source >= 7.1 (RFC 1000).
+ */
+export type ArrayHelper = DirectInvokable<{
+  <T extends unknown[]>(...args: T): T;
+}>;
+
+/**
+ * `(hash key=value ...)` — packs the named arguments into a typed object.
+ * Built-in keyword in ember-source >= 7.1 (RFC 999).
+ */
+export type HashHelper = DirectInvokable<{
+  <T extends Record<string, unknown>>(args: T): T;
+}>;

package/types/-private/intrinsics/comparison.d.ts

@@ -0,0 +1,36 @@
+import { DirectInvokable } from '@glint/template/-private/integration';
+
+/**
+ * `(eq a b)` — strict equality of two values. Built-in keyword in
+ * ember-source >= 7.1 (RFC 561). The result is narrowed when both sides are
+ * literal types so templates such as `{{#if (eq this.kind "primary")}}` get
+ * accurate type information.
+ */
+export type EqHelper = DirectInvokable<{
+  <A, B>(a: A, b: B): [A] extends [B] ? ([B] extends [A] ? true : boolean) : boolean;
+}>;
+
+/** `(neq a b)` — strict inequality. Built-in keyword in ember-source >= 7.1. */
+export type NeqHelper = DirectInvokable<{
+  <A, B>(a: A, b: B): [A] extends [B] ? ([B] extends [A] ? false : boolean) : boolean;
+}>;
+
+/** `(lt a b)` — numeric less-than. Built-in keyword in ember-source >= 7.1. */
+export type LtHelper = DirectInvokable<{
+  (a: number, b: number): boolean;
+}>;
+
+/** `(lte a b)` — numeric less-than-or-equal. Built-in keyword in ember-source >= 7.1. */
+export type LteHelper = DirectInvokable<{
+  (a: number, b: number): boolean;
+}>;
+
+/** `(gt a b)` — numeric greater-than. Built-in keyword in ember-source >= 7.1. */
+export type GtHelper = DirectInvokable<{
+  (a: number, b: number): boolean;
+}>;
+
+/** `(gte a b)` — numeric greater-than-or-equal. Built-in keyword in ember-source >= 7.1. */
+export type GteHelper = DirectInvokable<{
+  (a: number, b: number): boolean;
+}>;

package/types/-private/intrinsics/element.d.ts

@@ -0,0 +1,14 @@
+import { ComponentLike } from '@glint/template';
+import { DirectInvokable } from '@glint/template/-private/integration';
+
+/**
+ * `(element "tag-name")` — yields a component bound to a dynamic HTML tag
+ * name. Built-in keyword in ember-source >= 7.1 (RFC 389).
+ */
+export type ElementHelper = DirectInvokable<{
+  (tagName: string): ComponentLike<{
+    Element: Element;
+    Args: Record<string, unknown>;
+    Blocks: { default: [] };
+  }>;
+}>;