@glint/template 1.7.7 → 1.7.8

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

@@ -9,7 +9,6 @@ import {
   TemplateContext,
   Invokable,
   NamedArgs,
-  UnwrapNamedArgs,
 } from '../integration';
 import {
   AttributesForElement,
@@ -17,7 +16,7 @@ import {
   MathMlElementForTagName,
   SVGElementForTagName,
 } from './types';
-import { MaybeNamed, PrebindArgs } from '../signature';
+import { MaybeNamed, PrebindArgs, UnionKeysOf } from '../signature';
 
 /**
  * Used during emit to denote an object literal that corresponds
@@ -189,18 +188,14 @@ 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 & keyof UnwrapNamedArgs<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 & keyof UnwrapNamedArgs<Named>>
-            >,
+            ...MaybeNamed<PrebindArgs<NonNullable<Named>, keyof GivenNamed & UnionKeysOf<Named>>>,
           ]
         ) => T
       : (...args: Args extends unknown[] ? Args : never) => T;

package/-private/integration.d.ts

@@ -74,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

@@ -56,17 +56,34 @@ export type ComponentSignatureElement<S> = S extends { Element: infer Element }
     : 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.7",
+  "version": "1.7.8",
   "repository": "typed-ember/glint",
   "description": "Type definitions to back typechecking for Glimmer templates",
   "license": "MIT",