@glint/template 1.4.1-unstable.fd8b303 → 1.5.0

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

@@ -45,7 +45,7 @@ export declare function emitContent(value: ContentValue): void;
  *     });
  */
 export declare function emitElement<Name extends string>(
-  name: Name,
+  name: Name
 ): { element: ElementForTagName<Name> };
 
 /*
@@ -65,7 +65,7 @@ export declare function emitElement<Name extends string>(
  *     });
  */
 export declare function emitComponent<T extends ComponentReturn<any, any>>(
-  component: T,
+  component: T
 ): {
   element: T extends ComponentReturn<any, infer El> ? El : any;
   blockParams: T extends ComponentReturn<infer Yields, any> ? Required<Yields> : any;
@@ -80,7 +80,7 @@ export declare function emitComponent<T extends ComponentReturn<any, any>>(
  */
 export declare function templateExpression<
   Signature extends AnyFunction = () => ComponentReturn<{}>,
-  Context extends AnyContext = TemplateContext<void, {}, {}, void>,
+  Context extends AnyContext = TemplateContext<void, {}, {}, void>
 >(f: (𝚪: Context, χ: never) => void): new () => InvokableInstance<Signature> & HasContext<Context>;
 
 /*
@@ -98,7 +98,7 @@ export declare function templateExpression<
  */
 export declare function templateForBackingValue<Args extends unknown[], Context extends AnyContext>(
   backingValue: abstract new (...args: Args) => HasContext<Context>,
-  body: (𝚪: Context, χ: never) => void,
+  body: (𝚪: Context, χ: never) => void
 ): abstract new () => unknown;
 
 /*
@@ -112,7 +112,7 @@ export declare function templateForBackingValue<Args extends unknown[], Context
  */
 export declare function yieldToBlock<Context extends AnyContext, K extends keyof Context['blocks']>(
   𝚪: Context,
-  to: K,
+  to: K
 ): (...values: NonNullable<Context['blocks'][K]>) => void;
 
 /*
@@ -124,7 +124,7 @@ export declare function yieldToBlock<Context extends AnyContext, K extends keyof
  */
 export declare function applySplattributes<
   SourceElement extends Element,
-  TargetElement extends SourceElement,
+  TargetElement extends SourceElement
 >(source: SourceElement, target: TargetElement): void;
 
 /*

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

@@ -27,13 +27,13 @@ import { ResolveOrReturn } from './types';
  *    down to their most general form, which breaks complex declarations like `fn` that
  *    rely on having multiple overrides to be typed correctly.
  *
- * In modern Ember.js, plain functions can themselves be invokables with their
- * own particular resolution semantics.
+ * In GlimmerX (and potentially other future environments), plain functions can themselves
+ * be invokables with their own particular resolution semantics.
  */
 
 export declare function resolve<T extends DirectInvokable>(item: T): T[typeof InvokeDirect];
 export declare function resolve<Args extends unknown[], Instance extends InvokableInstance>(
-  item: (abstract new (...args: Args) => Instance) | null | undefined,
+  item: (abstract new (...args: Args) => Instance) | null | undefined
 ): (...args: Parameters<Instance[typeof Invoke]>) => ReturnType<Instance[typeof Invoke]>;
 
 /*
@@ -59,8 +59,8 @@ export declare const resolveOrReturn: ResolveOrReturn<typeof resolve>;
 
 export declare function resolveForBind<T extends DirectInvokable>(item: T): T[typeof InvokeDirect];
 export declare function resolveForBind<Args extends unknown[], Instance extends InvokableInstance>(
-  item: abstract new (...args: Args) => Instance,
+  item: abstract new (...args: Args) => Instance
 ): (...args: Parameters<Instance[typeof Invoke]>) => ReturnType<Instance[typeof Invoke]>;
 export declare function resolveForBind<Args extends unknown[], Instance extends InvokableInstance>(
-  item: null | undefined | (abstract new (...args: Args) => Instance),
+  item: null | undefined | (abstract new (...args: Args) => Instance)
 ): null | ((...args: Parameters<Instance[typeof Invoke]>) => ReturnType<Instance[typeof Invoke]>);

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

@@ -13,5 +13,5 @@ export type ElementForTagName<Name extends string> = Name extends keyof HTMLElem
     ? HTMLElementTagNameMap[Name] & SVGElementTagNameMap[Name]
     : HTMLElementTagNameMap[Name]
   : Name extends keyof SVGElementTagNameMap
-    ? SVGElementTagNameMap[Name]
-    : Element;
+  ? SVGElementTagNameMap[Name]
+  : Element;

package/-private/index.d.ts

@@ -128,17 +128,19 @@ export type ModifierLike<S = unknown> = Invokable<
  * consumers would still be obligated to provide a `@message`
  * arg when invoking the yielded component.
  */
-export type WithBoundArgs<T extends Invokable<AnyFunction>, BoundArgs extends NamedArgNames<T>> =
-  T extends Invokable<(...args: [...positional: infer P, named: infer N]) => infer R>
-    ? Invokable<
-        (
-          ...args: [
-            ...positional: P,
-            ...named: MaybeNamed<PrebindArgs<UnwrapNamedArgs<NonNullable<N>>, BoundArgs>>,
-          ]
-        ) => R
-      >
-    : never;
+export type WithBoundArgs<
+  T extends Invokable<AnyFunction>,
+  BoundArgs extends NamedArgNames<T>
+> = T extends Invokable<(...args: [...positional: infer P, named: infer N]) => infer R>
+  ? Invokable<
+      (
+        ...args: [
+          ...positional: P,
+          ...named: MaybeNamed<PrebindArgs<UnwrapNamedArgs<NonNullable<N>>, BoundArgs>>
+        ]
+      ) => R
+    >
+  : never;
 
 /**
  * Similar to `WithBoundArgs`, this utility type provides a shorthand
@@ -171,14 +173,13 @@ export type WithBoundArgs<T extends Invokable<AnyFunction>, BoundArgs extends Na
  */
 export type WithBoundPositionals<
   T extends Invokable<AnyFunction> | AnyFunction,
-  Count extends number,
-> =
-  T extends Invokable<(el: infer El, ...args: infer A) => ModifierReturn>
-    ? Invokable<(el: El, ...args: SliceFrom<A, Count>) => ModifierReturn>
-    : T extends Invokable<(...args: infer A) => infer R>
-      ? Invokable<(...args: SliceFrom<A, Count>) => R>
-      : T extends (...args: infer A) => infer R
-        ? Invokable<(...args: SliceFrom<A, Count>) => R>
-        : never;
+  Count extends number
+> = T extends Invokable<(el: infer El, ...args: infer A) => ModifierReturn>
+  ? Invokable<(el: El, ...args: SliceFrom<A, Count>) => ModifierReturn>
+  : T extends Invokable<(...args: infer A) => infer R>
+  ? Invokable<(...args: SliceFrom<A, Count>) => R>
+  : T extends (...args: infer A) => infer R
+  ? Invokable<(...args: SliceFrom<A, Count>) => R>
+  : never;
 
 export {};

package/-private/integration.d.ts

@@ -69,11 +69,12 @@ export interface NamedArgsMarker {
   [NamedArgs]: true;
 }
 
-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>
-      : never
-    : 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>
+    : never
+  : never;
 
 export type UnwrapNamedArgs<T> = T extends NamedArgs<infer U> ? U : T;

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

@@ -7,16 +7,16 @@ type PrefixOf<T extends unknown[]> = T extends [arg: infer Arg, ...rest: infer R
 
 export type BindInvokableKeyword<Prefix extends number, Kind> = DirectInvokable<{
   // {{bind invokable}}
+  <Args extends unknown[], T extends Kind>(invokable: (...args: Args) => T): Invokable<
+    (...args: Args) => T
+  >;
   <Args extends unknown[], T extends Kind>(
-    invokable: (...args: Args) => T,
-  ): Invokable<(...args: Args) => T>;
-  <Args extends unknown[], T extends Kind>(
-    invokable: ((...args: Args) => T) | null | undefined,
+    invokable: ((...args: Args) => T) | null | undefined
   ): null | Invokable<(...args: Args) => T>;
   // {{bind invokableWithOnlyNamedArgs name="foo"}}
   <Named, Return extends Kind, GivenNamed>(
     invokable: (named: NamedArgs<Named>) => Return,
-    named: NamedArgs<Partial<Named> & GivenNamed>,
+    named: NamedArgs<Partial<Named> & GivenNamed>
   ): Invokable<
     (
       ...named: MaybeNamed<
@@ -26,7 +26,7 @@ export type BindInvokableKeyword<Prefix extends number, Kind> = DirectInvokable<
   >;
   <Named, Return extends Kind, GivenNamed>(
     invokable: null | undefined | ((named: NamedArgs<Named>) => Return),
-    named: NamedArgs<Partial<Named> & GivenNamed>,
+    named: NamedArgs<Partial<Named> & GivenNamed>
   ): null | Invokable<
     (
       ...named: MaybeNamed<
@@ -37,27 +37,27 @@ export type BindInvokableKeyword<Prefix extends number, Kind> = DirectInvokable<
   // {{bind invokableWithNamedAndPositionalArgs name="foo"}}
   <Named, Positional extends unknown[], Return extends Kind, GivenNamed extends Partial<Named>>(
     invokable: (...args: [...Positional, NamedArgs<Named>]) => Return,
-    named: GivenNamed,
+    named: GivenNamed
   ): Invokable<
     (
       ...args: [
         ...Positional,
         ...MaybeNamed<
           PrebindArgs<NonNullable<Named>, keyof GivenNamed & keyof UnwrapNamedArgs<Named>>
-        >,
+        >
       ]
     ) => Return
   >;
   <Named, Positional extends unknown[], Return extends Kind, GivenNamed extends Partial<Named>>(
     invokable: (...args: [...Positional, NamedArgs<Named>]) => Return,
-    named: GivenNamed,
+    named: GivenNamed
   ): Invokable<
     (
       ...args: [
         ...Positional,
         ...MaybeNamed<
           PrebindArgs<NonNullable<Named>, keyof GivenNamed & keyof UnwrapNamedArgs<Named>>
-        >,
+        >
       ]
     ) => Return
   >;
@@ -65,7 +65,7 @@ export type BindInvokableKeyword<Prefix extends number, Kind> = DirectInvokable<
   <
     Positional extends any[],
     Return extends Kind,
-    GivenPositional extends PrefixOf<SliceFrom<Positional, Prefix>>,
+    GivenPositional extends PrefixOf<SliceFrom<Positional, Prefix>>
   >(
     invokable: (...args: [...Positional]) => Return,
     ...args: GivenPositional
@@ -73,14 +73,14 @@ export type BindInvokableKeyword<Prefix extends number, Kind> = DirectInvokable<
     (
       ...args: [
         ...SliceTo<Positional, Prefix>,
-        ...SliceFrom<SliceFrom<Positional, Prefix>, GivenPositional['length']>,
+        ...SliceFrom<SliceFrom<Positional, Prefix>, GivenPositional['length']>
       ]
     ) => Return
   >;
   <
     Positional extends any[],
     Return extends Kind,
-    GivenPositional extends PrefixOf<SliceFrom<Positional, Prefix>>,
+    GivenPositional extends PrefixOf<SliceFrom<Positional, Prefix>>
   >(
     invokable: null | undefined | ((...args: [...Positional]) => Return),
     ...args: GivenPositional
@@ -88,7 +88,7 @@ export type BindInvokableKeyword<Prefix extends number, Kind> = DirectInvokable<
     (
       ...args: [
         ...SliceTo<Positional, Prefix>,
-        ...SliceFrom<SliceFrom<Positional, Prefix>, GivenPositional['length']>,
+        ...SliceFrom<SliceFrom<Positional, Prefix>, GivenPositional['length']>
       ]
     ) => Return
   >;

package/-private/keywords/let.d.ts

@@ -1,9 +1,7 @@
 import { ComponentReturn, DirectInvokable } from '../integration';
 
 export type LetKeyword = DirectInvokable<{
-  <T extends unknown[]>(
-    ...values: T
-  ): ComponentReturn<{
+  <T extends unknown[]>(...values: T): ComponentReturn<{
     default: T;
   }>;
 }>;

package/-private/signature.d.ts

@@ -10,7 +10,7 @@ import { NamedArgs, UnwrapNamedArgs } from './integration';
  */
 export type InvokableArgs<Args> = [
   ...positional: Constrain<Get<Args, 'Positional'>, Array<unknown>, []>,
-  ...named: MaybeNamed<NamedArgs<Get<Args, 'Named'>>>,
+  ...named: MaybeNamed<NamedArgs<Get<Args, 'Named'>>>
 ];
 
 /** Given a signature `S`, get back the normalized `Args` type. */
@@ -72,12 +72,12 @@ export type TupleOfSize<Len extends number, Acc extends unknown[] = []> = Acc['l
 export type SliceTo<T extends unknown[], Index extends number> = T['length'] extends Index
   ? T
   : T extends [...infer Rest, any?]
-    ? SliceTo<Rest, Index>
-    : [];
+  ? SliceTo<Rest, Index>
+  : [];
 
 export type SliceFrom<T extends unknown[], Index extends number> = T extends [
   ...TupleOfSize<Index>,
-  ...infer Rest,
+  ...infer Rest
 ]
   ? Rest
   : [];

package/package.json

@@ -1,15 +1,13 @@
 {
   "name": "@glint/template",
-  "version": "1.4.1-unstable.fd8b303",
+  "version": "1.5.0",
   "repository": "typed-ember/glint",
   "description": "Type definitions to back typechecking for Glimmer templates",
   "license": "MIT",
   "author": "Dan Freeman (https://github.com/dfreeman)",
   "types": "-private/index.d.ts",
   "scripts": {
-    "test": "echo 'no standalone tests within this project'",
-    "test:typecheck": "tsc --project __tests__",
-    "test:tsc": "echo 'no standalone typecheck within this project'"
+    "test": "tsc --project __tests__"
   },
   "files": [
     "README.md",
@@ -18,6 +16,7 @@
   ],
   "devDependencies": {
     "@glimmer/component": "^1.1.2",
+    "@glimmerx/component": "^0.6.7",
     "@types/ember__component": "~4.0.8",
     "expect-type": "^0.15.0",
     "sums-up": "^2.1.0"