@glint/template 0.9.1 → 0.9.4

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

@@ -64,16 +64,36 @@ export declare function emitComponent<T extends AcceptsBlocks<any, any>>(
   blockParams: T extends AcceptsBlocks<infer Yields, any> ? Required<Yields> : any;
 };
 
-/**
- * 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
+/*
+ * Wraps a template body that appears as a standalone expression and is therefore not
+ * associated with any backing value.
+ *
+ * The given callback accepts a template context value as well as an instance of the
  * environment's DSL export.
  */
-export declare function template<
+export declare function templateExpression<
   Signature extends AnyFunction = (args: EmptyObject) => AcceptsBlocks<EmptyObject>,
   Context extends AnyContext = TemplateContext<void, EmptyObject, EmptyObject, void>
 >(f: (𝚪: Context, χ: never) => void): new () => Invokable<Signature> & HasContext<Context>;
 
+/*
+ * Wraps a template body that's backed by a known value (typically a class), either
+ * via a `.hbs` association to a default export or via embedding e.g. with `<template>`.
+ *
+ * The given callback accepts a template context value as well as an instance of the
+ * environment's DSL export.
+ *
+ * Note that this signature is structured carefully to trigger TypeScript's higher-order function
+ * type inference so that any type parameters on the given backing value (if it's a class) will
+ * be preserved and reflected in the template body. Both the `Args` type and the constructor return
+ * value are necessary for this, despite the fact that we don't actually do anything with those
+ * types (see https://github.com/microsoft/TypeScript/pull/30215).
+ */
+export declare function templateForBackingValue<Args extends unknown[], Context extends AnyContext>(
+  backingValue: abstract new (...args: Args) => HasContext<Context>,
+  body: (𝚪: Context, χ: never) => void
+): abstract new () => unknown;
+
 /*
  * Used in template bodies to encode a `{{yield}}` statement.
  *
@@ -83,10 +103,10 @@ export declare function template<
  *
  *     yieldToBlock(𝚪, 'name', foo, bar);
  */
-export declare function yieldToBlock<Context extends AnyContext, K extends keyof Context['yields']>(
+export declare function yieldToBlock<Context extends AnyContext, K extends keyof Context['blocks']>(
   𝚪: Context,
   to: K,
-  ...values: NonNullable<Context['yields'][K]>
+  ...values: NonNullable<Context['blocks'][K]>
 ): void;
 
 /*

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

@@ -1,4 +1,4 @@
-import { EmptyObject, HasContext } from '@glint/template/-private/integration';
+import { EmptyObject } from '@glint/template/-private/integration';
 
 type Constructor<T> = abstract new (...args: never[]) => T;
 
@@ -19,13 +19,3 @@ export type ElementForTagName<Name extends string> = Name extends keyof HTMLElem
   : Name extends keyof SVGElementTagNameMap
   ? SVGElementTagNameMap[Name]
   : Element;
-
-/**
- * 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
-  : T extends Constructor<HasContext<infer Context>>
-  ? Context
-  : unknown;

package/-private/integration.d.ts

@@ -2,6 +2,9 @@
 // module exports the symbols and types necessary to declare a class or
 // other entity as integrating with Glint's template system.
 
+import { EmptyObject } from '@glimmer/component/-private/component';
+export { EmptyObject };
+
 /** Any function, which is the tighest bound we can put on an object's `[Invoke]` field. */
 export type AnyFunction = (...params: any) => any;
 
@@ -23,8 +26,7 @@ export type HasContext<T extends AnyContext = AnyContext> = { [Context]: T };
 // These shenanigans are necessary to get TS to report when named args
 // are passed to a signature that doesn't expect any, because `{}` is
 // special-cased in the type system not to trigger EPC.
-declare const EmptyObject: unique symbol;
-export type EmptyObject = { [EmptyObject]?: void };
+
 export type GuardEmpty<T> = T extends any ? (keyof T extends never ? EmptyObject : T) : never;
 
 declare const Element: unique symbol;
@@ -47,10 +49,10 @@ export type AcceptsBlocks<BlockImpls, El = null> = {
  * Determines the type of `this` and any `@arg`s used in a template,
  * as well as valid `{{yield}}` invocations and `...attributes` usage.
  */
-export type TemplateContext<This, Args, Yields, Element> = {
+export type TemplateContext<This, Args, Blocks, Element> = {
   this: This;
   args: Args;
-  yields: Yields;
+  blocks: Blocks;
   element: Element;
 };
 

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@glint/template",
-  "version": "0.9.1",
+  "version": "0.9.4",
   "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": {
-    "lint": "eslint . --max-warnings 0 && prettier --check .",
     "test": "tsc --project __tests__"
   },
   "files": [
@@ -20,7 +19,7 @@
   },
   "devDependencies": {
     "@glimmer/component": "^1.1.2",
-    "@glimmerx/component": "^0.4.2",
+    "@glimmerx/component": "^0.6.7",
     "@types/ember__component": "~4.0.8",
     "expect-type": "0.11.0",
     "sums-up": "^2.1.0"