@glint/template 1.0.0-beta.4 → 1.0.0-beta.5

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

@@ -47,3 +47,20 @@ export declare function resolve<Args extends unknown[], Instance extends Invokab
  */
 
 export declare const resolveOrReturn: ResolveOrReturn<typeof resolve>;
+
+/*
+ * Binding helpers like `{{component}}` and `{{helper}}` accept a variety of possible
+ * environment-specific initial arguments. This variant `resolve` signature allows
+ * environments to dictate how that argument is interpreted before being handed off to
+ * the actual helper definition. By resolving to the internal invokable form as described
+ * above, TypeScript can "do the right thing" in more cases for type inference, particularly
+ * with invokables whose signatures include type parameters.
+ */
+
+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
+): (...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)
+): null | ((...args: Parameters<Instance[typeof Invoke]>) => ReturnType<Instance[typeof Invoke]>);

package/-private/index.d.ts

@@ -15,6 +15,7 @@ import {
   InvokableArgs,
   MaybeNamed,
   PrebindArgs,
+  SliceFrom,
 } from './signature';
 
 /**
@@ -141,4 +142,44 @@ export type WithBoundArgs<
     >
   : never;
 
+/**
+ * Similar to `WithBoundArgs`, this utility type provides a shorthand
+ * for specifying the type of a helper or modifier whose positional
+ * argument(s) have been pre-bound.
+ *
+ * Given the type of the helper or modifier in question and the number
+ * of positional arguments that have been pre-bound, this helper returns
+ * the same item back, but without those leading positional arguments.
+ *
+ * For instance, given a helper `FooHelper` with positional arg types
+ * `[secret: symbol, name: string, age: number]`, then if you wrote
+ * the following in a template:
+ *
+ * ```handlebars
+ * {{yield (helper FooHelper this.secret)}}
+ * ```
+ *
+ * You could represent that in your signature as:
+ *
+ * ```ts
+ * Blocks: {
+ *   default: [WithBoundPositionals<typeof FooHelper, 1>];
+ * };
+ * ```
+ *
+ * Note that you can use `WithBoundPositionals` and `WithBoundArgs`
+ * together if you're pre-binding both positional and named arguments
+ * in the same location.
+ */
+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;
+
 export {};

package/-private/keywords/-bind-invokable.d.ts

@@ -0,0 +1,99 @@
+import { DirectInvokable, Invokable, NamedArgs, UnwrapNamedArgs } from '../integration';
+import { MaybeNamed, PrebindArgs, SliceFrom, SliceTo } from '../signature';
+
+type PrefixOf<T extends unknown[]> = T extends [arg: infer Arg, ...rest: infer Rest]
+  ? [] | [Arg, ...PrefixOf<Rest>]
+  : T;
+
+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
+  ): null | Invokable<(...args: Args) => T>;
+  // {{bind invokableWithOnlyNamedArgs name="foo"}}
+  <Named, Return extends Kind, GivenNamed>(
+    invokable: (named: NamedArgs<Named>) => Return,
+    named: NamedArgs<Partial<Named> & GivenNamed>
+  ): Invokable<
+    (
+      ...named: MaybeNamed<
+        PrebindArgs<NonNullable<Named>, keyof GivenNamed & keyof UnwrapNamedArgs<Named>>
+      >
+    ) => Return
+  >;
+  <Named, Return extends Kind, GivenNamed>(
+    invokable: null | undefined | ((named: NamedArgs<Named>) => Return),
+    named: NamedArgs<Partial<Named> & GivenNamed>
+  ): null | Invokable<
+    (
+      ...named: MaybeNamed<
+        PrebindArgs<NonNullable<Named>, keyof GivenNamed & keyof UnwrapNamedArgs<Named>>
+      >
+    ) => Return
+  >;
+  // {{bind invokableWithNamedAndPositionalArgs name="foo"}}
+  <Named, Positional extends unknown[], Return extends Kind, GivenNamed extends Partial<Named>>(
+    invokable: (...args: [...Positional, NamedArgs<Named>]) => Return,
+    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
+  ): Invokable<
+    (
+      ...args: [
+        ...Positional,
+        ...MaybeNamed<
+          PrebindArgs<NonNullable<Named>, keyof GivenNamed & keyof UnwrapNamedArgs<Named>>
+        >
+      ]
+    ) => Return
+  >;
+  // {{bind invokable positional}}
+  <
+    Named,
+    Positional extends any[],
+    Return extends Kind,
+    GivenPositional extends PrefixOf<SliceFrom<Positional, Prefix>>
+  >(
+    invokable: (...args: [...Positional, NamedArgs<Named>]) => Return,
+    ...args: GivenPositional
+  ): Invokable<
+    (
+      ...args: [
+        ...SliceTo<Positional, Prefix>,
+        ...SliceFrom<SliceFrom<Positional, Prefix>, GivenPositional['length']>,
+        ...MaybeNamed<NamedArgs<Named>>
+      ]
+    ) => Return
+  >;
+  <
+    Named,
+    Positional extends any[],
+    Return extends Kind,
+    GivenPositional extends PrefixOf<SliceFrom<Positional, Prefix>>
+  >(
+    invokable: null | undefined | ((...args: [...Positional, NamedArgs<Named>]) => Return),
+    ...args: GivenPositional
+  ): null | Invokable<
+    (
+      ...args: [
+        ...SliceTo<Positional, Prefix>,
+        ...SliceFrom<SliceFrom<Positional, Prefix>, GivenPositional['length']>,
+        ...MaybeNamed<NamedArgs<Named>>
+      ]
+    ) => Return
+  >;
+}>;

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

@@ -1,58 +1,4 @@
-import { WithBoundArgs } from '../index';
-import {
-  ComponentReturn,
-  DirectInvokable,
-  InvokableInstance,
-  NamedArgs,
-  Invokable,
-  NamedArgNames,
-  AnyFunction,
-  UnwrapNamedArgs,
-} from '../integration';
+import { ComponentReturn } from '../integration';
+import { BindInvokableKeyword } from './-bind-invokable';
 
-type PartiallyAppliedComponent<Component, Args> = Component extends Invokable<AnyFunction>
-  ? WithBoundArgs<
-      Component,
-      Exclude<Args extends NamedArgNames<Component> ? Args : never, typeof NamedArgs>
-    >
-  : never;
-
-export type ComponentKeyword = DirectInvokable<{
-  <
-    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> = {}
-  >(
-    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>
-  >;
-}>;
+export type ComponentKeyword = BindInvokableKeyword<0, ComponentReturn<any, any>>;

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

@@ -0,0 +1,3 @@
+import { BindInvokableKeyword } from './-bind-invokable';
+
+export type HelperKeyword = BindInvokableKeyword<0, any>;

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

@@ -0,0 +1,4 @@
+import { ModifierReturn } from '../integration';
+import { BindInvokableKeyword } from './-bind-invokable';
+
+export type ModifierKeyword = BindInvokableKeyword<1, ModifierReturn>;

package/-private/keywords.d.ts

@@ -3,6 +3,8 @@ export { DebuggerKeyword } from './keywords/debugger';
 export { EachKeyword } from './keywords/each';
 export { HasBlockKeyword } from './keywords/has-block';
 export { HasBlockParamsKeyword } from './keywords/has-block-params';
+export { HelperKeyword } from './keywords/helper';
 export { InElementKeyword } from './keywords/in-element';
 export { LetKeyword } from './keywords/let';
+export { ModifierKeyword } from './keywords/modifier';
 export { WithKeyword } from './keywords/with';

package/-private/signature.d.ts

@@ -64,3 +64,20 @@ export type MaybeNamed<T> = T extends any
 
 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;
+
+export type TupleOfSize<Len extends number, Acc extends unknown[] = []> = Acc['length'] extends Len
+  ? Acc
+  : TupleOfSize<Len, [any, ...Acc]>;
+
+export type SliceTo<T extends unknown[], Index extends number> = T['length'] extends Index
+  ? T
+  : T extends [...infer Rest, any?]
+  ? SliceTo<Rest, Index>
+  : [];
+
+export type SliceFrom<T extends unknown[], Index extends number> = T extends [
+  ...TupleOfSize<Index>,
+  ...infer Rest
+]
+  ? Rest
+  : [];

package/package.json

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