@glint/template 0.8.2 → 0.9.1

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

@@ -1,3 +1,4 @@
+import { AttrValue, ContentValue } from '..';
 import {
   AcceptsBlocks,
   AnyContext,
@@ -8,18 +9,18 @@ import {
   Invokable,
   TemplateContext,
 } from '../integration';
-import { ElementForTagName, EmittableValue } from './types';
+import { ElementForTagName } from './types';
 
 /*
- * Emits the given value to the DOM. This corresponds to a mustache
- * statement either at the top level:
+ * Emits the given value as top-level content to the DOM. This:
  *
- *     {{value}}
- *     {{value foo=bar}}
- *     <div data-x={{value foo=bar}}>
- *     <div data-x="hello {{value foo=bar}}">
+ *     Hello, {{world}}
+ *
+ * Would produce code like:
+ *
+ *     emitContent(resolveOrReturn(value)({}))
  */
-export declare function emitValue(value: AcceptsBlocks<{}, any> | EmittableValue): void;
+export declare function emitContent(value: ContentValue): void;
 
 /*
  * Emits an element of the given name, providing a value to the
@@ -106,7 +107,7 @@ export declare function applySplattributes<
  *     <div foo={{bar}}></div>
  *     <AnotherComponent foo={{bar}} />
  */
-export declare function applyAttributes(element: Element, attrs: Record<string, unknown>): void;
+export declare function applyAttributes(element: Element, attrs: Record<string, AttrValue>): void;
 
 /*
  * Applies a modifier to an element or component.

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

@@ -29,12 +29,3 @@ export type ResolveContext<T> = T extends HasContext<infer 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`.
-type SafeString = { toHTML(): string };
-
-/**
- * Represents values that can safely be emitted into the DOM i.e. as `<span>{{value}}</span>`.
- */
-export type EmittableValue = SafeString | Element | string | number | boolean | null | void;

package/-private/index.d.ts

@@ -8,6 +8,36 @@ import {
 } from './integration';
 import { ExpandSignature } from '@glimmer/component/-private/component';
 
+/**
+ * Any value that can be safely emitted into the DOM as top-level content,
+ * i.e. as `<div>{{value}}</div>`.
+ *
+ * This includes primitives like strings, numbers and booleans; "nothing"
+ * values like `null` and `undefined`; DOM nodes; and blockless curly
+ * component invocations.
+ */
+export type ContentValue =
+  | string
+  | number
+  | boolean
+  | null
+  | undefined
+  | void
+  | SafeString
+  | Node
+  | ArglessCurlyComponent;
+
+/**
+ * Any value that can be safely set as an HTML attribute on a DOM node.
+ * This includes strings, numbers, booleans and `null`/`undefined`.
+ *
+ * Note that this does not include functions, as writing something like
+ * `onclick={{this.handleClick}}` in a template ultimately relies on
+ * fallback behavior in the VM to set the `onclick` property, and is
+ * better performed using the `{{on}}` modifier.
+ */
+export type AttrValue = string | number | boolean | null | undefined | SafeString;
+
 /**
  * A value that is invokable like a component in a template. In an
  * appropriate Glint environment, subclasses of `EmberComponent` and
@@ -112,3 +142,13 @@ type InvokableArgs<S> = [
   named: GuardEmpty<Get<Get<S, 'Args'>, 'Named'>>,
   ...positional: Constrain<Get<Get<S, 'Args'>, 'Positional'>, Array<unknown>, []>
 ];
+
+// This encompasses both @glimmer/runtime and @ember/template's notion of `SafeString`s,
+// and this coverage is tested in `emit-content.test.ts`.
+type SafeString = { toHTML(): string };
+
+// `{{foo}}` becomes `emitContent(resolveOrReturn(foo)({})`, which means if `foo`
+// is a component that accepts no args, then this is a valid invocation.
+type ArglessCurlyComponent = AcceptsBlocks<{}, any>;
+
+export {};

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

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

package/package.json

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