@glint/template 0.5.1 → 0.6.3

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

@@ -1,4 +1,13 @@
-import { AcceptsBlocks, AnyContext, BoundModifier } from '../integration';
+import {
+  AcceptsBlocks,
+  AnyContext,
+  AnyFunction,
+  BoundModifier,
+  EmptyObject,
+  HasContext,
+  Invokable,
+  TemplateContext,
+} from '../integration';
 import { ElementForTagName, EmittableValue } from './types';
 
 /*
@@ -50,14 +59,19 @@ export declare function emitElement<Name extends string>(
 export declare function emitComponent<T extends AcceptsBlocks<any, any>>(
   component: T
 ): {
-  element: T extends AcceptsBlocks<any, infer El> ? El : null;
-  blockParams: T extends AcceptsBlocks<infer Yields, any> ? Required<Yields> : never;
+  element: T extends AcceptsBlocks<any, infer El> ? El : any;
+  blockParams: T extends AcceptsBlocks<infer Yields, any> ? Required<Yields> : any;
 };
 
 /**
- * Acts as a top-level wrapper for translated template bodies.
+ * Acts as a top-level wrapper for translated template bodies. The given
+ * callback accepts a template context value as well as an instance of the
+ * environment's DSL export.
  */
-export declare function template(f: (𝚪: AnyContext) => void): void;
+export declare function template<
+  Signature extends AnyFunction = (args: EmptyObject) => AcceptsBlocks<EmptyObject>,
+  Context extends AnyContext = TemplateContext<void, EmptyObject, EmptyObject, void>
+>(f: (𝚪: Context, χ: never) => void): new () => Invokable<Signature> & HasContext<Context>;
 
 /*
  * Used in template bodies to encode a `{{yield}}` statement.

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

@@ -1,4 +1,5 @@
-import { DirectInvokable, EmptyObject, Invokable, Invoke, InvokeDirect } from '../integration';
+import { DirectInvokable, Invokable, Invoke, InvokeDirect } from '../integration';
+import { ResolveOrReturn } from './types';
 
 /*
  * We have multiple ways of representing invokable values, dictated by certain constraints
@@ -45,8 +46,4 @@ export declare function resolve<Args extends unknown[], Instance extends Invokab
  * value of the appropriate type.
  */
 
-export declare function resolveOrReturn<T extends DirectInvokable>(item: T): T[typeof InvokeDirect];
-export declare function resolveOrReturn<Args extends unknown[], Instance extends Invokable>(
-  item: (new (...args: Args) => Instance) | null | undefined
-): (...args: Parameters<Instance[typeof Invoke]>) => ReturnType<Instance[typeof Invoke]>;
-export declare function resolveOrReturn<T>(item: T): (args: EmptyObject) => T;
+export declare const resolveOrReturn: ResolveOrReturn<typeof resolve>;

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

@@ -1,7 +1,13 @@
-import { HasContext } from '@glint/template/-private/integration';
+import { EmptyObject, HasContext } from '@glint/template/-private/integration';
 
 type Constructor<T> = new (...args: any) => T;
 
+/**
+ * A utility for constructing the type of an environment's `resolveOrReturn` from
+ * the type of its `resolve` function.
+ */
+export type ResolveOrReturn<T> = T & (<U>(item: U) => (args: EmptyObject) => U);
+
 /**
  * Given a tag name, returns an appropriate `Element` subtype.
  * NOTE: This will return a union for elements that exist both in HTML and SVG. Technically, this will be too permissive.
@@ -15,10 +21,14 @@ export type ElementForTagName<Name extends string> = Name extends keyof HTMLElem
   : Element;
 
 /**
- * Given the instance type of a component backing class, produces the appropriate
+ * Given the constructor or instance type of a component backing class, produces the appropriate
  * `TemplateContext` type for its template.
  */
-export type ResolveContext<T> = T extends HasContext<infer Context> ? Context : unknown;
+export type ResolveContext<T> = T extends HasContext<infer Context>
+  ? Context
+  : T extends Constructor<HasContext<infer Context>>
+  ? Context
+  : unknown;
 
 // This encompasses both @glimmer/runtime and @ember/template's notion of `SafeString`s,
 // and this coverage is tested in `emit-value.test.ts`.

package/-private/integration.d.ts

@@ -37,7 +37,7 @@ export type BoundModifier<El extends Element> = { [Modifier]: (el: El) => void }
  * Denotes that the associated entity may be invoked with the given
  * blocks, yielding params of the appropriate type.
  */
-export type AcceptsBlocks<BlockImpls extends AnyBlocks, El extends Element | null = null> = {
+export type AcceptsBlocks<BlockImpls, El extends Element | null = null> = {
   [Element]: El;
   (blocks: BlockImpls): { [Blocks]: true };
 };

package/-private/keywords/in-element.d.ts

@@ -1,5 +1,5 @@
 import { AcceptsBlocks, DirectInvokable } from '../integration';
 
 export type InElementKeyword = DirectInvokable<{
-  (args: { insertBefore?: null }, element: Element): AcceptsBlocks<{ default: [] }>;
+  (args: { insertBefore?: null | undefined }, element: Element): AcceptsBlocks<{ default: [] }>;
 }>;

package/package.json

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