@glint/template 1.4.1-unstable.2e45a79 → 1.4.1-unstable.34c4510

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

@@ -38,14 +38,14 @@ export declare function emitContent(value: ContentValue): void;
  *
  * Would produce code like:
  *
- *     emitElement('div', (𝛄) => {
- *       applySplattributes(𝚪.element, 𝛄.element);
- *       applyAttributes(𝛄.element, { class: 'hello' });
- *       applyModifier(𝛄.element, resolve(on)({}, 'click', this.clicked));
+ *     emitElement('div', (__glintY__) => {
+ *       applySplattributes(__glintRef__.element, __glintY__.element);
+ *       applyAttributes(__glintY__.element, { class: 'hello' });
+ *       applyModifier(__glintY__.element, resolve(on)({}, 'click', this.clicked));
  *     });
  */
 export declare function emitElement<Name extends string>(
-  name: Name
+  name: Name,
 ): { element: ElementForTagName<Name> };
 
 /*
@@ -60,12 +60,12 @@ export declare function emitElement<Name extends string>(
  * This form of invocation is the only one in a template that may have
  * blocks bound to it. The final line above would produce code like:
  *
- *     emitComponent(resolve(Value)({ foo: bar })), (𝛄) => {
- *       applyModifier(𝛄.element, resolve(baz)({}));
+ *     emitComponent(resolve(Value)({ foo: bar })), (__glintY__) => {
+ *       applyModifier(__glintY__.element, resolve(baz)({}));
  *     });
  */
 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,8 +80,10 @@ export declare function emitComponent<T extends ComponentReturn<any, any>>(
  */
 export declare function templateExpression<
   Signature extends AnyFunction = () => ComponentReturn<{}>,
-  Context extends AnyContext = TemplateContext<void, {}, {}, void>
->(f: (𝚪: Context, χ: never) => void): new () => InvokableInstance<Signature> & HasContext<Context>;
+  Context extends AnyContext = TemplateContext<void, {}, {}, void>,
+>(
+  f: (__glintRef__: Context, __glintDSL__: never) => void,
+): new () => InvokableInstance<Signature> & HasContext<Context>;
 
 /*
  * Wraps a template body that's backed by a known value (typically a class), either
@@ -98,7 +100,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: (__glintRef__: Context, __glintDSL__: never) => void,
 ): abstract new () => unknown;
 
 /*
@@ -108,11 +110,11 @@ export declare function templateForBackingValue<Args extends unknown[], Context
  *
  * Is equivalent to:
  *
- *     yieldToBlock(𝚪, 'name')(foo, bar);
+ *     yieldToBlock(__glintRef__, 'name')(foo, bar);
  */
 export declare function yieldToBlock<Context extends AnyContext, K extends keyof Context['blocks']>(
-  𝚪: Context,
-  to: K
+  __glintRef__: Context,
+  to: K,
 ): (...values: NonNullable<Context['blocks'][K]>) => void;
 
 /*
@@ -124,7 +126,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

@@ -33,7 +33,7 @@ import { ResolveOrReturn } from './types';
 
 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,19 +128,17 @@ 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
@@ -173,13 +171,14 @@ export type WithBoundArgs<
  */
 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,12 +69,11 @@ 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) | null | undefined
+    invokable: (...args: Args) => T,
+  ): Invokable<(...args: Args) => T>;
+  <Args extends unknown[], T extends Kind>(
+    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,7 +1,9 @@
 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,13 +1,15 @@
 {
   "name": "@glint/template",
-  "version": "1.4.1-unstable.2e45a79",
+  "version": "1.4.1-unstable.34c4510",
   "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": "tsc --project __tests__"
+    "test": "echo 'no standalone tests within this project'",
+    "test:typecheck": "tsc --project __tests__",
+    "test:tsc": "echo 'no standalone typecheck within this project'"
   },
   "files": [
     "README.md",