@glint/template 1.7.6 → 1.7.8

package/-private/dsl/emit.d.ts

@@ -7,6 +7,7 @@ import {
   HasContext,
   InvokableInstance,
   TemplateContext,
+  Invokable,
   NamedArgs,
 } from '../integration';
 import {
@@ -15,6 +16,7 @@ import {
   MathMlElementForTagName,
   SVGElementForTagName,
 } from './types';
+import { MaybeNamed, PrebindArgs, UnionKeysOf } from '../signature';
 
 /**
  * Used during emit to denote an object literal that corresponds
@@ -173,3 +175,32 @@ export declare function applyModifier(boundModifier: ModifierReturn): void;
  * syntax.
  */
 export declare function noop(value: unknown): void;
+
+/*
+ * Pre-binds named args while preserving generic type parameters (#1068).
+ * Uses Args/T holistic capture instead of Named/Return decomposition.
+ * The keyword's old decomposing overloads validate arg types but erase T;
+ * this function preserves T but doesn't validate. The transform emits both
+ * via a comma expression so errors come from the keyword (mapped) and the
+ * result comes from here (T-preserving).
+ */
+type BindNamedResult<Args, T, GivenNamed> =
+  // Named-only args (required or optional — handles double-currying)
+  Args extends [NamedArgs<infer Named>?]
+    ? (
+        ...named: MaybeNamed<PrebindArgs<NonNullable<Named>, keyof GivenNamed & UnionKeysOf<Named>>>
+      ) => T
+    : // Positional + named args
+      Args extends [...infer Positional, NamedArgs<infer Named>]
+      ? (
+          ...args: [
+            ...Positional,
+            ...MaybeNamed<PrebindArgs<NonNullable<Named>, keyof GivenNamed & UnionKeysOf<Named>>>,
+          ]
+        ) => T
+      : (...args: Args extends unknown[] ? Args : never) => T;
+
+export declare function bindInvokable<Args extends unknown[], T, GivenNamed>(
+  invokable: (...args: Args) => T,
+  named: NamedArgs<GivenNamed>,
+): Invokable<BindNamedResult<Args, T, GivenNamed>>;

package/-private/integration.d.ts

@@ -36,9 +36,14 @@ export type ModifierReturn = { [Modifier]: true };
  * Denotes that the associated entity may be invoked with the given
  * blocks, yielding params of the appropriate type.
  */
+// The original conditional `El extends Element ? El : null` deferred for
+// generic conditional types like `ElementFromTagName<T>` (#610). Replaced
+// with `El extends null ? unknown : El` which only fires for literal null
+// (not conditional types) and converts null → unknown for ComponentLike
+// equivalence.
 export type ComponentReturn<BlockDefs, El = null> = {
   [Blocks]: BlockDefs;
-  [Element]: El extends Element ? El : null;
+  [Element]: El extends null ? unknown : El;
 };
 
 /**
@@ -69,10 +74,14 @@ export interface NamedArgsMarker {
   [NamedArgs]: true;
 }
 
+// Distributes so that a union type yields the keys of every constituent;
+// plain `keyof` over a union only sees keys common to all constituents.
+type KeysOfConstituents<T> = T extends unknown ? keyof T : never;
+
 export type NamedArgNames<T extends Invokable<AnyFunction>> =
   T extends Invokable<(...args: infer A) => any>
     ? A extends [...positional: infer _, named?: infer N]
-      ? Exclude<keyof NonNullable<N>, typeof NamedArgs>
+      ? Exclude<KeysOfConstituents<NonNullable<N>>, typeof NamedArgs>
       : never
     : never;
 

package/-private/keywords/-bind-invokable.d.ts

@@ -1,5 +1,5 @@
-import { DirectInvokable, Invokable, NamedArgs, UnwrapNamedArgs } from '../integration';
-import { MaybeNamed, PrebindArgs, SliceFrom, SliceTo } from '../signature';
+import { DirectInvokable, Invokable, NamedArgs } from '../integration';
+import { MaybeNamed, PrebindArgs, SliceFrom, SliceTo, UnionKeysOf } from '../signature';
 
 type PrefixOf<T extends unknown[]> = T extends [arg: infer Arg, ...rest: infer Rest]
   ? [] | [Arg, ...PrefixOf<Rest>]
@@ -19,9 +19,7 @@ export type BindInvokableKeyword<Prefix extends number, Kind> = DirectInvokable<
     named: NamedArgs<Partial<Named> & GivenNamed>,
   ): Invokable<
     (
-      ...named: MaybeNamed<
-        PrebindArgs<NonNullable<Named>, keyof GivenNamed & keyof UnwrapNamedArgs<Named>>
-      >
+      ...named: MaybeNamed<PrebindArgs<NonNullable<Named>, keyof GivenNamed & UnionKeysOf<Named>>>
     ) => Return
   >;
   <Named, Return extends Kind, GivenNamed>(
@@ -29,9 +27,7 @@ export type BindInvokableKeyword<Prefix extends number, Kind> = DirectInvokable<
     named: NamedArgs<Partial<Named> & GivenNamed>,
   ): null | Invokable<
     (
-      ...named: MaybeNamed<
-        PrebindArgs<NonNullable<Named>, keyof GivenNamed & keyof UnwrapNamedArgs<Named>>
-      >
+      ...named: MaybeNamed<PrebindArgs<NonNullable<Named>, keyof GivenNamed & UnionKeysOf<Named>>>
     ) => Return
   >;
   // {{bind invokableWithNamedAndPositionalArgs name="foo"}}
@@ -42,9 +38,7 @@ export type BindInvokableKeyword<Prefix extends number, Kind> = DirectInvokable<
     (
       ...args: [
         ...Positional,
-        ...MaybeNamed<
-          PrebindArgs<NonNullable<Named>, keyof GivenNamed & keyof UnwrapNamedArgs<Named>>
-        >,
+        ...MaybeNamed<PrebindArgs<NonNullable<Named>, keyof GivenNamed & UnionKeysOf<Named>>>,
       ]
     ) => Return
   >;
@@ -55,9 +49,7 @@ export type BindInvokableKeyword<Prefix extends number, Kind> = DirectInvokable<
     (
       ...args: [
         ...Positional,
-        ...MaybeNamed<
-          PrebindArgs<NonNullable<Named>, keyof GivenNamed & keyof UnwrapNamedArgs<Named>>
-        >,
+        ...MaybeNamed<PrebindArgs<NonNullable<Named>, keyof GivenNamed & UnionKeysOf<Named>>>,
       ]
     ) => Return
   >;

package/-private/signature.d.ts

@@ -44,23 +44,46 @@ export type ComponentSignatureBlocks<S> = S extends { Blocks: infer Blocks }
   : {};
 
 /** Given a component signature `S`, get back the `Element` type. */
+// The original `NonNullable<Element> extends never` check deferred for generic
+// conditional types like ElementFromTagName<T>, collapsing them to unknown
+// (#610). Using `Element extends null` instead only fires for literal null
+// (preserving null → unknown for ComponentLike equivalence) without breaking
+// conditional types — TypeScript can verify the deferred result still extends
+// Element because neither branch of ElementFromTagName<T> is null.
 export type ComponentSignatureElement<S> = S extends { Element: infer Element }
-  ? NonNullable<Element> extends never
+  ? Element extends null
     ? unknown
     : Element
   : unknown;
 
-export type PrebindArgs<T, Args extends keyof UnwrapNamedArgs<T>> = NamedArgs<
-  Omit<UnwrapNamedArgs<T>, Args> & Partial<Pick<UnwrapNamedArgs<T>, Args>>
+// This distributes over union `T` so that each constituent only has the bound
+// keys it actually declares omitted/made-optional. A non-distributive
+// `Omit<A | B, ...>` would collapse the union to its common keys, losing the
+// per-constituent shape (#1144).
+export type PrebindArgs<T, Args extends UnionKeysOf<T>> = NamedArgs<
+  T extends any
+    ? Omit<UnwrapNamedArgs<T>, Args & keyof UnwrapNamedArgs<T>> &
+        Partial<Pick<UnwrapNamedArgs<T>, Args & keyof UnwrapNamedArgs<T>>>
+    : never
 >;
 
-export type MaybeNamed<T> = T extends any
-  ? {} extends UnwrapNamedArgs<T>
-    ? keyof UnwrapNamedArgs<T> extends never
+// Keys across all constituents of a (possibly union) named-args type. Plain
+// `keyof UnwrapNamedArgs<T>` would only see keys common to every constituent.
+export type UnionKeysOf<T> = T extends any ? keyof UnwrapNamedArgs<T> : never;
+
+// Note: this must produce a single parameter tuple rather than distributing a
+// union `T` into a union of tuples. A union of tuples breaks contravariant
+// assignability against the `(named: NamedArgs<Named>)` patterns used by
+// `{{component}}`/`{{helper}}`/`{{modifier}}` to pre-bind named args (#1144).
+// The checks below are still union-aware: `{} extends A | B` holds when any
+// constituent accepts an empty hash, and `UnionKeysOf` collects keys from all
+// constituents.
+export type MaybeNamed<T> =
+  {} extends UnwrapNamedArgs<T>
+    ? [UnionKeysOf<T>] extends [never]
       ? []
       : [named?: T]
-    : [named: T]
-  : never;
+    : [named: T];
 
 export type Get<T, K, Otherwise = unknown> = K extends keyof T ? T[K] : Otherwise;
 export type Constrain<T, Constraint, Otherwise = Constraint> = T extends Constraint ? T : Otherwise;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glint/template",
-  "version": "1.7.6",
+  "version": "1.7.8",
   "repository": "typed-ember/glint",
   "description": "Type definitions to back typechecking for Glimmer templates",
   "license": "MIT",