@glint/ember-tsc 1.8.2 → 1.8.4

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

@@ -4,14 +4,7 @@ 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 { GtHelper, GteHelper, LtHelper, LteHelper } from '../intrinsics/comparison';
 import { EachKeyword } from '../intrinsics/each';
 import { EachInKeyword } from '../intrinsics/each-in';
 import { ElementHelper } from '../intrinsics/element';
@@ -331,7 +324,8 @@ interface KeywordsForEmber71Members {
    *
    * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/eq
    */
-  eq: EqHelper;
+  // `{{eq}}` is emitted as the native `===` operator in `ember-tsc`.
+  eq: void;
 
   /**
    * `{{fn}}` is a helper that receives a function and some arguments, and
@@ -459,7 +453,8 @@ interface KeywordsForEmber71Members {
    *
    * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/neq
    */
-  neq: NeqHelper;
+  // `{{neq}}` is emitted as the native `!==` operator in `ember-tsc`.
+  neq: void;
 
   /**
    * The `{{not}}` helper returns the logical negation of its argument using

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

@@ -1,19 +1,12 @@
 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;
-}>;
+// NOTE: `eq`/`neq` (RFC 561) are not represented here. Because their runtime is
+// exactly `left === right` / `left !== right`, they are emitted as the native
+// `===`/`!==` operators (see the `ember-template-imports` environment's
+// `specialForms`) — which, unlike a boolean-returning helper type, lets
+// TypeScript narrow discriminated unions in `{{#if (eq foo.kind "a")}}`. The
+// `lt`/`lte`/`gt`/`gte` keywords below have no narrowing benefit and remain
+// ordinary helpers.
 
 /** `(lt a b)` — numeric less-than. Built-in keyword in ember-source >= 7.1. */
 export type LtHelper = DirectInvokable<{

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

@@ -6,8 +6,28 @@ import { DirectInvokable } from '@glint/template/-private/integration';
  * name. Built-in keyword in ember-source >= 7.1 (RFC 389).
  */
 export type ElementHelper = DirectInvokable<{
-  (tagName: string): ComponentLike<{
-    Element: Element;
+  // `const K` preserves the literal tag name (e.g. `"video"`) through Glint's
+  // `resolve()` inference; without it TypeScript widens the argument to `string`
+  // and narrowing collapses to the base `Element`. The `string & {}` member lets
+  // a genuinely dynamic (non-literal) tag name still match and fall back to
+  // `Element`, covering both HTML and SVG.
+  <const K extends keyof HTMLElementTagNameMap | keyof SVGElementTagNameMap | (string & {})>(
+    tagName: K,
+  ): ComponentLike<{
+    // A known HTML or SVG tag name narrows to the corresponding element type.
+    // When a name exists in both maps (e.g. `a`, `script`, `style`, `title`)
+    // the HTML element wins, matching the default (non-SVG) namespace at
+    // runtime. An empty string renders the block without a wrapping element, so
+    // there is no element to receive attributes (`null`, which makes applying
+    // any attribute a type error). Any other (dynamic) tag name falls back to
+    // the base `Element`, covering both HTML and SVG.
+    Element: K extends keyof HTMLElementTagNameMap
+      ? HTMLElementTagNameMap[K]
+      : K extends keyof SVGElementTagNameMap
+        ? SVGElementTagNameMap[K]
+        : K extends ''
+          ? null
+          : Element;
     Args: Record<string, unknown>;
     Blocks: { default: [] };
   }>;

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

@@ -1,12 +1,16 @@
 import { DirectInvokable } from '@glint/template/-private/integration';
 import ObjectProxy from '@ember/object/proxy';
-import '@ember/object/-private/types';
 
 // This hack lets us support both the stable/preview types from `ember-source`
 // and the classic types still live on DefinitelyTyped. If using the DT types,
-// this acts as a declaration merge for a module which is then integrated via
-// the rest of the DT types. If using the stable/preview types, this ends up
-// being a no-op.
+// the `declare module` below acts as a declaration merge for a module which is
+// then integrated via the rest of the DT types. If using the stable/preview
+// types, the module does not exist and this ends up being a no-op.
+//
+// Note: we intentionally do *not* add a side-effect `import '@ember/object/-private/types'`
+// here. TypeScript 6.0 errors (TS2882) on a side-effect import of a module that
+// cannot be resolved, which is exactly the no-op (ember-source) case above. The
+// `declare module` augmentation still merges into the DT module when it exists.
 declare const GetSetMarker: unique symbol;
 declare module '@ember/object/-private/types' {
   interface ComputedPropertyMarker<Get, Set = Get> {

package/types/-private/intrinsics/truth-helpers.d.ts

@@ -1,32 +1,49 @@
 import { DirectInvokable } from '@glint/template/-private/integration';
 
-import type { FirstFalsy, FirstTruthy, MaybeTruthy, TruthConvert } from './truth-convert';
+import type { Falsy, FirstFalsy, FirstTruthy, MaybeTruthy } from './truth-convert';
 
 /**
  * `(and a b ...)` — short-circuit logical AND. Returns the first falsy
  * positional argument or the last argument. Available as a built-in keyword
  * in ember-source >= 7.1 (RFC 560).
+ *
+ * The runtime requires **at least two** arguments (it throws otherwise), so the
+ * signature pins two leading positionals before the rest.
  */
 export type AndHelper = DirectInvokable<{
-  <T extends MaybeTruthy[]>(...args: T): FirstFalsy<T>;
+  <A extends MaybeTruthy, B extends MaybeTruthy, Rest extends MaybeTruthy[]>(
+    a: A,
+    b: B,
+    ...rest: Rest
+  ): FirstFalsy<[A, B, ...Rest]>;
 }>;
 
 /**
  * `(or a b ...)` — short-circuit logical OR. Returns the first truthy
  * positional argument or the last argument. Available as a built-in keyword
  * in ember-source >= 7.1 (RFC 560).
+ *
+ * The runtime requires **at least two** arguments (it throws otherwise), so the
+ * signature pins two leading positionals before the rest.
  */
 export type OrHelper = DirectInvokable<{
-  <T extends MaybeTruthy[]>(...args: T): FirstTruthy<T>;
+  <A extends MaybeTruthy, B extends MaybeTruthy, Rest extends MaybeTruthy[]>(
+    a: A,
+    b: B,
+    ...rest: Rest
+  ): FirstTruthy<[A, B, ...Rest]>;
 }>;
 
 /**
- * `(not value)` — boolean negation using truthy semantics matching the rest
- * of Ember's template-side helpers. Built-in keyword in ember-source >= 7.1
- * (RFC 560).
+ * `(not value)` — boolean negation using Handlebars truthiness semantics.
+ * Built-in keyword in ember-source >= 7.1 (RFC 560).
+ *
+ * Typed as a type predicate over Ember's `Falsy` type so that using it as a
+ * condition narrows the operand: in `{{#if (not value)}}` the operand is
+ * narrowed to its falsy members, and in the `{{else}}` branch to its truthy
+ * members. (As a predicate its *value* is `boolean` rather than a `true`/
+ * `false` literal — narrowing in conditions is the more useful guarantee.)
  */
 export type NotHelper = DirectInvokable<{
-  <T>(
-    value: T,
-  ): TruthConvert<T> extends true ? false : TruthConvert<T> extends false ? true : boolean;
+  <T>(value: T): value is Extract<T, Falsy>;
 }>;