@glint/template 0.9.6 → 1.0.0-beta.1

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

@@ -1,16 +1,23 @@
 import { AttrValue, ContentValue } from '..';
 import {
-  AcceptsBlocks,
+  ComponentReturn,
   AnyContext,
   AnyFunction,
-  BoundModifier,
-  EmptyObject,
+  ModifierReturn,
   HasContext,
-  Invokable,
+  InvokableInstance,
   TemplateContext,
+  NamedArgs,
 } from '../integration';
 import { ElementForTagName } from './types';
 
+/**
+ * Used during emit to denote an object literal that corresponds
+ * to the use of named args rather than passing an object value
+ * directly.
+ */
+export declare const NamedArgsMarker: NamedArgs<unknown>;
+
 /*
  * Emits the given value as top-level content to the DOM. This:
  *
@@ -57,11 +64,11 @@ export declare function emitElement<Name extends string>(
  *       applyModifier(𝛄.element, resolve(baz)({}));
  *     });
  */
-export declare function emitComponent<T extends AcceptsBlocks<any, any>>(
+export declare function emitComponent<T extends ComponentReturn<any, any>>(
   component: T
 ): {
-  element: T extends AcceptsBlocks<any, infer El> ? El : any;
-  blockParams: T extends AcceptsBlocks<infer Yields, any> ? Required<Yields> : any;
+  element: T extends ComponentReturn<any, infer El> ? El : any;
+  blockParams: T extends ComponentReturn<infer Yields, any> ? Required<Yields> : any;
 };
 
 /*
@@ -72,9 +79,9 @@ export declare function emitComponent<T extends AcceptsBlocks<any, any>>(
  * environment's DSL export.
  */
 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>;
+  Signature extends AnyFunction = () => ComponentReturn<{}>,
+  Context extends AnyContext = TemplateContext<void, {}, {}, void>
+>(f: (𝚪: Context, χ: never) => void): new () => InvokableInstance<Signature> & HasContext<Context>;
 
 /*
  * Wraps a template body that's backed by a known value (typically a class), either
@@ -101,13 +108,12 @@ export declare function templateForBackingValue<Args extends unknown[], Context
  *
  * Is equivalent to:
  *
- *     yieldToBlock(𝚪, 'name', foo, bar);
+ *     yieldToBlock(𝚪, 'name')(foo, bar);
  */
 export declare function yieldToBlock<Context extends AnyContext, K extends keyof Context['blocks']>(
   𝚪: Context,
-  to: K,
-  ...values: NonNullable<Context['blocks'][K]>
-): void;
+  to: K
+): (...values: NonNullable<Context['blocks'][K]>) => void;
 
 /*
  * Applies `...attributes` that were passed to a component down
@@ -135,7 +141,11 @@ export declare function applyAttributes(element: Element, attrs: Record<string,
  *     <div {{someModifier}}></div>
  *     <AnotherComponent {{someModifier}} />
  */
-export declare function applyModifier<TargetElement extends Element>(
-  element: TargetElement,
-  modifier: BoundModifier<TargetElement>
-): void;
+export declare function applyModifier(boundModifier: ModifierReturn): void;
+
+/*
+ * Used to consume imported identifiers like `hash` or `array` when
+ * we treat them as a special form to be translated into native
+ * syntax.
+ */
+export declare function noop(value: unknown): void;

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

@@ -1,4 +1,4 @@
-import { DirectInvokable, Invokable, Invoke, InvokeDirect } from '../integration';
+import { DirectInvokable, InvokableInstance, Invoke, InvokeDirect } from '../integration';
 import { ResolveOrReturn } from './types';
 
 /*
@@ -9,12 +9,12 @@ import { ResolveOrReturn } from './types';
  *     (args: Named, ...positional: Positional) => Result
  *
  * `Named` and `Positional` represent the respective types of the named and positional
- * args accepted, and `Result` is either `CreatesModifier`, `AcceptsBlocks<...>`, or any
+ * args accepted, and `Result` is either `CreatesModifier`, `ComponentReturn<...>`, or any
  * other type to simply indicate that the invokable returns a value.
  *
  * In the core, invokables can take one of two forms:
  *
- *  - `new (...) => Invokable<T>`: this is the typical signature for items such as a
+ *  - `new (...) => InvokableInstance<T>`: this is the typical signature for items such as a
  *    component subclass. In resolving this form, we need to break apart the construct
  *    signature and reconstruct it as a regular function, which has the implicit effect
  *    of preserving type parameters for polymorphic components in the resulting function
@@ -32,7 +32,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 Invokable>(
+export declare function resolve<Args extends unknown[], Instance extends InvokableInstance>(
   item: (abstract new (...args: Args) => Instance) | null | undefined
 ): (...args: Parameters<Instance[typeof Invoke]>) => ReturnType<Instance[typeof Invoke]>;
 

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

@@ -1,12 +1,8 @@
-import { EmptyObject } from '@glint/template/-private/integration';
-
-type Constructor<T> = abstract new (...args: never[]) => 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);
+export type ResolveOrReturn<T> = T & (<U>(item: U) => () => U);
 
 /**
  * Given a tag name, returns an appropriate `Element` subtype.

package/-private/dsl.d.ts

@@ -1,6 +1,6 @@
 // This module exports functions and types directly referenced by
-// the output of `@glint/transform`. It comprises the basis from
-// which environments construct their exports.
+// the output of `@glint/core`'s transform layer. It comprises the
+// basis from which environments construct their exports.
 
 export * from './dsl/resolve';
 export * from './dsl/emit';

package/-private/index.d.ts

@@ -1,12 +1,21 @@
 import {
-  AcceptsBlocks,
+  ComponentReturn,
   AnyFunction,
-  BoundModifier,
-  GuardEmpty,
+  ModifierReturn,
   FlattenBlockParams,
   Invokable,
+  NamedArgNames,
+  UnwrapNamedArgs,
 } from './integration';
-import { ExpandSignature } from '@glimmer/component/-private/component';
+import {
+  ComponentSignatureArgs,
+  ComponentSignatureBlocks,
+  ComponentSignatureElement,
+  Get,
+  InvokableArgs,
+  MaybeNamed,
+  PrebindArgs,
+} from './signature';
 
 /**
  * Any value that can be safely emitted into the DOM as top-level content,
@@ -27,6 +36,14 @@ export type ContentValue =
   | Node
   | ArglessCurlyComponent;
 
+// 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 = ComponentReturn<{}, any>;
+
 /**
  * Any value that can be safely set as an HTML attribute on a DOM node.
  * This includes strings, numbers, booleans and `null`/`undefined`.
@@ -47,13 +64,12 @@ export type AttrValue = string | number | boolean | null | undefined | SafeStrin
  * The `S` signature parameter here is of the same form as the one
  * accepted by both the Ember and Glimmer `Component` base classes.
  */
-export type ComponentLike<S = unknown> = InvokableConstructor<
+export type ComponentLike<S = unknown> = Invokable<
   (
-    named: GuardEmpty<ExpandSignature<S>['Args']['Named']>,
-    ...positional: ExpandSignature<S>['Args']['Positional']
-  ) => AcceptsBlocks<
-    FlattenBlockParams<ExpandSignature<S>['Blocks']>,
-    ExpandSignature<S>['Element']
+    ...args: InvokableArgs<ComponentSignatureArgs<S>>
+  ) => ComponentReturn<
+    FlattenBlockParams<ComponentSignatureBlocks<S>>,
+    ComponentSignatureElement<S>
   >
 >;
 
@@ -66,8 +82,8 @@ export type ComponentLike<S = unknown> = InvokableConstructor<
  * The `S` signature parameter here is of the same form as the one
  * accepted by `Helper` and `helper`.
  */
-export type HelperLike<S = unknown> = InvokableConstructor<
-  (...args: InvokableArgs<S>) => Get<S, 'Return', unknown>
+export type HelperLike<S = unknown> = Invokable<
+  (...args: InvokableArgs<Get<S, 'Args'>>) => Get<S, 'Return', unknown>
 >;
 
 /**
@@ -79,8 +95,8 @@ export type HelperLike<S = unknown> = InvokableConstructor<
  * The `S` signature parameter here is of the same form as the ones
  * accepted by `Modifier` and `modifier`.
  */
-export type ModifierLike<S = unknown> = InvokableConstructor<
-  (...args: InvokableArgs<S>) => BoundModifier<Constrain<Get<S, 'Element'>, Element>>
+export type ModifierLike<S = unknown> = Invokable<
+  (element: Get<S, 'Element'>, ...args: InvokableArgs<Get<S, 'Args'>>) => ModifierReturn
 >;
 
 /**
@@ -112,43 +128,17 @@ export type ModifierLike<S = unknown> = InvokableConstructor<
  * arg when invoking the yielded component.
  */
 export type WithBoundArgs<
-  T extends InvokableConstructor<AnyFunction>,
+  T extends Invokable<AnyFunction>,
   BoundArgs extends NamedArgNames<T>
-> = T extends InvokableConstructor<
-  (named: infer Named, ...positional: infer Positional) => infer Result
->
-  ? InvokableConstructor<
+> = T extends Invokable<(...args: [...positional: infer P, named: infer N]) => infer R>
+  ? Invokable<
       (
-        named: GuardEmpty<Omit<Named, BoundArgs> & Partial<Pick<Named, BoundArgs & keyof Named>>>,
-        ...positional: Positional
-      ) => Result
+        ...args: [
+          ...positional: P,
+          ...named: MaybeNamed<PrebindArgs<UnwrapNamedArgs<NonNullable<N>>, BoundArgs>>
+        ]
+      ) => R
     >
   : never;
 
-type InvokableConstructor<F extends AnyFunction> = abstract new (...args: any) => Invokable<F>;
-type NamedArgNames<T extends InvokableConstructor<AnyFunction>> = T extends InvokableConstructor<
-  (named: infer Named, ...positional: any) => any
->
-  ? keyof Named
-  : never;
-
-type Get<T, K, Otherwise = unknown> = K extends keyof T ? T[K] : Otherwise;
-type Constrain<T, Constraint, Otherwise = Constraint> = T extends Constraint ? T : Otherwise;
-
-// We use the imported `ExpandSignature` for component signatures, as they have
-// different layers of possible shorthand, but modifiers and helpers only have
-// one structure they can specify their args in, so this utility is sufficient.
-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/integration.d.ts

@@ -1,9 +1,10 @@
-// While the entire `@glint/template` package is currently private, this
-// 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 };
+// While everything in the `@glint/template` package other than its main
+// entrypoint is "private", this module exports the symbols and types
+// necessary to declare a class or other entity as integrating with Glint's
+// template system.
+// In most cases it should be possible to declare integrations in terms of
+// `ComponentLike`/`HelperLike`/`ModifierLike`, but these declarations are
+// the primitives on which those types are built.
 
 /** Any function, which is the tighest bound we can put on an object's `[Invoke]` field. */
 export type AnyFunction = (...params: any) => any;
@@ -18,31 +19,26 @@ export declare const InvokeDirect: unique symbol;
 export type DirectInvokable<T extends AnyFunction = AnyFunction> = { [InvokeDirect]: T };
 
 export declare const Invoke: unique symbol;
-export type Invokable<T extends AnyFunction = AnyFunction> = { [Invoke]: T };
+export type InvokableInstance<T extends AnyFunction = AnyFunction> = { [Invoke]: T };
+export type Invokable<F extends AnyFunction> = abstract new (...args: any) => InvokableInstance<F>;
 
 export declare const Context: unique symbol;
 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.
-
-export type GuardEmpty<T> = T extends any ? (keyof T extends never ? EmptyObject : T) : never;
-
 declare const Element: unique symbol;
 declare const Modifier: unique symbol;
 declare const Blocks: unique symbol;
 
 /** Denotes a modifier whose arguments have been bound and is ready to be attached to an element. */
-export type BoundModifier<El extends Element> = { [Modifier]: (el: El) => void };
+export type ModifierReturn = { [Modifier]: true };
 
 /**
  * Denotes that the associated entity may be invoked with the given
  * blocks, yielding params of the appropriate type.
  */
-export type AcceptsBlocks<BlockImpls, El = null> = {
+export type ComponentReturn<BlockDefs, El = null> = {
+  [Blocks]: BlockDefs;
   [Element]: El extends Element ? El : null;
-  (blocks: BlockImpls): { [Blocks]: true };
 };
 
 /**
@@ -63,3 +59,22 @@ export type TemplateContext<This, Args, Blocks, Element> = {
 export type FlattenBlockParams<T> = {
   [K in keyof T]: T[K] extends { Params: { Positional: infer U } } ? U : T[K];
 };
+
+// This trio of declarations allows us to distinguish explicit named
+// argument invocation from "final positional argument is a hash"
+// situations.
+export declare const NamedArgs: unique symbol;
+export type NamedArgs<T> = T & NamedArgsMarker;
+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 UnwrapNamedArgs<T> = T extends NamedArgs<infer U> ? U : T;

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

@@ -1,17 +1,58 @@
-import { AcceptsBlocks, AnyBlocks, DirectInvokable, Invokable } from '../integration';
+import { WithBoundArgs } from '../index';
+import {
+  ComponentReturn,
+  DirectInvokable,
+  InvokableInstance,
+  NamedArgs,
+  Invokable,
+  NamedArgNames,
+  AnyFunction,
+  UnwrapNamedArgs,
+} from '../integration';
+
+type PartiallyAppliedComponent<Component, Args> = Component extends Invokable<AnyFunction>
+  ? WithBoundArgs<
+      Component,
+      Exclude<Args extends NamedArgNames<Component> ? Args : never, typeof NamedArgs>
+    >
+  : never;
 
 export type ComponentKeyword = DirectInvokable<{
   <
-    Args,
-    GivenArgs extends Partial<Args>,
-    Blocks extends AnyBlocks,
-    ConstructorArgs extends unknown[]
+    Named,
+    Positional extends unknown[],
+    Return extends ComponentReturn<any, any>,
+    ConstructorArgs extends unknown[],
+    GivenArgs extends Partial<Named> = {}
+  >(
+    component: abstract new (...args: ConstructorArgs) => InvokableInstance<
+      (...args: [...positional: Positional, named: Named]) => Return
+    >,
+    args?: NamedArgs<GivenArgs>
+  ): PartiallyAppliedComponent<
+    abstract new (...args: ConstructorArgs) => InvokableInstance<
+      (...args: [...positional: Positional, named: Named]) => Return
+    >,
+    keyof UnwrapNamedArgs<GivenArgs>
+  >;
+  <
+    Named,
+    Positional extends unknown[],
+    Return extends ComponentReturn<any, any>,
+    ConstructorArgs extends unknown[],
+    GivenArgs extends Partial<Named> = {}
   >(
-    args: GivenArgs,
-    component: new (...args: ConstructorArgs) => Invokable<(args: Args) => AcceptsBlocks<Blocks>>
-  ): new () => Invokable<
-    (
-      args: Omit<Args, keyof GivenArgs> & Partial<Pick<Args, keyof GivenArgs & keyof Args>>
-    ) => AcceptsBlocks<Blocks>
+    component:
+      | null
+      | undefined
+      | (abstract new (...args: ConstructorArgs) => InvokableInstance<
+          (...args: [...positional: Positional, named: Named]) => Return
+        >),
+    args?: NamedArgs<GivenArgs>
+  ): null | PartiallyAppliedComponent<
+    abstract new (...args: ConstructorArgs) => InvokableInstance<
+      (...args: [...positional: Positional, named: Named]) => Return
+    >,
+    keyof UnwrapNamedArgs<GivenArgs>
   >;
 }>;

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

@@ -1,5 +1,3 @@
-import { DirectInvokable, EmptyObject } from '../integration';
+import { HelperLike } from '../index';
 
-export type DebuggerKeyword = DirectInvokable<{
-  (args: EmptyObject): void;
-}>;
+export interface DebuggerKeyword extends HelperLike<{ Return: void }> {}

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

@@ -1,8 +1,16 @@
-import { AcceptsBlocks, DirectInvokable } from '../integration';
+import { ComponentLike } from '../index';
 
-export type EachKeyword = DirectInvokable<{
-  <T>(args: { key?: string }, items: readonly T[]): AcceptsBlocks<{
-    default: [T, number];
-    else?: [];
-  }>;
-}>;
+type ArrayLike<T> = ReadonlyArray<T> | Iterable<T>;
+
+export type EachKeyword = abstract new <T = any>() => InstanceType<
+  ComponentLike<{
+    Args: {
+      Positional: [items: Iterable<T> | null | undefined];
+      Named: { key?: string };
+    };
+    Blocks: {
+      default: [T, number];
+      else: [];
+    };
+  }>
+>;

package/-private/keywords/has-block-params.d.ts

@@ -1,5 +1,6 @@
-import { DirectInvokable, EmptyObject } from '../integration';
+import { HelperLike } from '../index';
 
-export type HasBlockParamsKeyword = DirectInvokable<{
-  (args: EmptyObject, blockName?: string): boolean;
+export type HasBlockParamsKeyword = HelperLike<{
+  Args: { Positional: [blockName?: string] };
+  Return: boolean;
 }>;

package/-private/keywords/has-block.d.ts

@@ -1,5 +1,6 @@
-import { DirectInvokable, EmptyObject } from '../integration';
+import { HelperLike } from '../index';
 
-export type HasBlockKeyword = DirectInvokable<{
-  (args: EmptyObject, blockName?: string): boolean;
+export type HasBlockKeyword = HelperLike<{
+  Args: { Positional: [blockName?: string] };
+  Return: boolean;
 }>;

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

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

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

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

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

@@ -1,8 +1,13 @@
-import { AcceptsBlocks, DirectInvokable, EmptyObject } from '../integration';
+import { ComponentLike } from '../index';
 
-export type WithKeyword = DirectInvokable<{
-  <T>(args: EmptyObject, value: T): AcceptsBlocks<{
-    default: [T];
-    else?: [];
-  }>;
-}>;
+export type WithKeyword = abstract new <T>() => InstanceType<
+  ComponentLike<{
+    Args: {
+      Positional: [value: T];
+    };
+    Blocks: {
+      default: [value: T];
+      else: [];
+    };
+  }>
+>;

package/-private/signature.d.ts

@@ -0,0 +1,64 @@
+// This module contains utilities for converting signature types defined
+// in userspace into our internal representation of an invokable's
+// function type signature.
+
+import { NamedArgs, UnwrapNamedArgs } from './integration';
+
+/**
+ * Given an "args hash" (e.g. `{ Named: {...}; Positional: [...] }`),
+ * returns a tuple type representing the parameters
+ */
+export type InvokableArgs<Args> = [
+  ...positional: Constrain<Get<Args, 'Positional'>, Array<unknown>, []>,
+  ...named: MaybeNamed<NamedArgs<Get<Args, 'Named'>>>
+];
+
+/** Given a signature `S`, get back the normalized `Args` type. */
+export type ComponentSignatureArgs<S> = S extends {
+  Args: infer Args;
+}
+  ? Args extends {
+      Named?: object;
+      Positional?: unknown[];
+    }
+    ? {
+        Named: Get<S['Args'], 'Named', {}>;
+        Positional: Get<S['Args'], 'Positional', []>;
+      }
+    : {
+        Named: S['Args'];
+        Positional: [];
+      }
+  : {
+      Named: keyof S extends 'Args' | 'Blocks' | 'Element' ? {} : S;
+      Positional: [];
+    };
+
+/** Given a signature `S`, get back the normalized `Blocks` type. */
+export type ComponentSignatureBlocks<S> = S extends { Blocks: infer Blocks }
+  ? {
+      [Block in keyof Blocks]: Blocks[Block] extends unknown[]
+        ? { Params: { Positional: Blocks[Block] } }
+        : Blocks[Block];
+    }
+  : {};
+
+/** Given a component signature `S`, get back the `Element` type. */
+export type ComponentSignatureElement<S> = S extends { Element: infer Element }
+  ? NonNullable<Element> extends never
+    ? unknown
+    : Element
+  : unknown;
+
+export type PrebindArgs<T, Args extends keyof UnwrapNamedArgs<T>> = NamedArgs<
+  Omit<UnwrapNamedArgs<T>, Args> & Partial<Pick<UnwrapNamedArgs<T>, Args>>
+>;
+
+export type MaybeNamed<T> = {} extends UnwrapNamedArgs<T>
+  ? keyof UnwrapNamedArgs<T> extends never
+    ? []
+    : [named?: T]
+  : [named: T];
+
+export type Get<T, K, Otherwise = unknown> = K extends keyof T ? T[K] : Otherwise;
+export type Constrain<T, Constraint, Otherwise = Constraint> = T extends Constraint ? T : Otherwise;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glint/template",
-  "version": "0.9.6",
+  "version": "1.0.0-beta.1",
   "repository": "typed-ember/glint",
   "description": "Type definitions to back typechecking for Glimmer templates",
   "license": "MIT",
@@ -14,9 +14,6 @@
     "-private",
     "*.d.ts"
   ],
-  "peerDependencies": {
-    "@glimmer/component": "^1.1.2"
-  },
   "devDependencies": {
     "@glimmer/component": "^1.1.2",
     "@glimmerx/component": "^0.6.7",