@discourse/types 0.0.1 → 2026.1.0-a5a0839

package/external-types/@glint__ember-tsc/types/-private/dsl/index.d.ts

@@ -0,0 +1,50 @@
+// Reference the scaffolding for our merged declarations for third party modules so
+// that vanilla TS will see those as long as authors have
+// `import '@glint/ember-tsc/environment-ember-template-imports'` somewhere in their project.
+
+/// <reference path="../../globals/index.d.ts" preserve="true" />
+/// <reference path="./integration-declarations.d.ts" preserve="true" />
+
+export * from '@glint/template/-private/dsl';
+export { Globals } from './globals';
+
+import { ResolveOrReturn } from '@glint/template/-private/dsl';
+import {
+  AnyContext,
+  AnyFunction,
+  ComponentReturn,
+  DirectInvokable,
+  HasContext,
+  InvokableInstance,
+  Invoke,
+  InvokeDirect,
+  TemplateContext,
+} from '@glint/template/-private/integration';
+
+// Items that can be directly invoked by value
+export declare function resolve<T extends DirectInvokable>(item: T): T[typeof InvokeDirect];
+// Items whose instance type can be invoked
+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]>;
+// Plain functions
+export declare function resolve<T extends ((...params: any) => any) | null | undefined>(
+  item: T,
+): NonNullable<T>;
+
+export declare const resolveOrReturn: ResolveOrReturn<typeof resolve>;
+
+// We customize the top-level `templateExpression` wrapper function for this environment to
+// return a type that's assignable to `TemplateOnlyComponent` from '@ember/component/template-only'.
+// Longer term we should rationalize this to a type that doesn't carry extra baggage
+// and likely comes from a more sensible path.
+
+import { TemplateOnlyComponent } from '@ember/component/template-only';
+
+export declare function templateExpression<
+  Signature extends AnyFunction = () => ComponentReturn<{}>,
+  Context extends AnyContext = TemplateContext<void, {}, {}, void>,
+>(
+  f: (__glintRef__: Context, __glintDSL__: never) => void,
+): TemplateOnlyComponent<never> &
+  (abstract new () => InvokableInstance<Signature> & HasContext<Context>);

package/external-types/@glint__ember-tsc/types/-private/dsl/integration-declarations.d.ts

@@ -0,0 +1,138 @@
+declare module '@glint/ember-tsc/types' {
+// This module is responsible for augmenting the upstream definitions of entities that interact
+// with templates to include the information necessary for Glint to typecheck them.
+
+import type { ComponentLike, HelperLike, ModifierLike } from '@glint/template';
+import type {
+  Context,
+  FlattenBlockParams,
+  HasContext,
+  TemplateContext,
+} from '@glint/template/-private/integration';
+import type {
+  ComponentSignatureArgs,
+  ComponentSignatureBlocks,
+  ComponentSignatureElement,
+} from '@glint/template/-private/signature';
+
+//////////////////////////////////////////////////////////////////////
+// Components
+
+import '@ember/component';
+import '@ember/component/template-only';
+import '@glimmer/component';
+
+type ComponentContext<This, S> = TemplateContext<
+  This,
+  ComponentSignatureArgs<S>['Named'],
+  FlattenBlockParams<ComponentSignatureBlocks<S>>,
+  ComponentSignatureElement<S>
+>;
+
+declare module '@glimmer/component' {
+  export default interface Component<S> extends InstanceType<ComponentLike<S>> {
+    [Context]: ComponentContext<this, S>;
+  }
+}
+
+import type { InputComponent as ImportedInputComponent } from '../intrinsics/input';
+import type { TextareaComponent as ImportedTextareaComponent } from '../intrinsics/textarea';
+declare module '@ember/component' {
+  export default interface Component<S> extends InstanceType<ComponentLike<S>> {
+    [Context]: ComponentContext<this, S>;
+  }
+  export interface Textarea extends ImportedTextareaComponent {}
+  export interface Input extends ImportedInputComponent {}
+}
+
+interface TemplateOnlyComponentInstance<S> extends InstanceType<ComponentLike<S>> {
+  [Context]: ComponentContext<null, S>;
+}
+
+// As with other abstract constructor types, this allows us to provide a class
+// and therefore have InstanceType work as needed, while forbidding construction
+// by end users.
+type TemplateOnlyConstructor<S> = abstract new () => TemplateOnlyComponentInstance<S>;
+
+declare module '@ember/component/template-only' {
+  export interface TemplateOnlyComponent<S> extends TemplateOnlyConstructor<S> {}
+}
+
+//////////////////////////////////////////////////////////////////////
+// Helpers
+
+import '@ember/component/helper';
+
+declare module '@ember/component/helper' {
+  export default interface Helper<S> extends InstanceType<HelperLike<S>> {}
+}
+
+//////////////////////////////////////////////////////////////////////
+// Modifiers
+
+import 'ember-modifier';
+
+declare module 'ember-modifier' {
+  export default interface ClassBasedModifier<S> extends InstanceType<ModifierLike<S>> {}
+}
+
+//////////////////////////////////////////////////////////////////////
+// Routes and Controllers
+
+import type Controller from '@ember/controller';
+import type Route from '@ember/routing/route';
+
+type ModelForRoute<T extends Route> = Awaited<ReturnType<T['model']>>;
+type ModelField<T> = { model: T };
+
+declare module '@ember/routing/route' {
+  export default interface Route {
+    [Context]: TemplateContext<
+      Controller & ModelField<ModelForRoute<this>>,
+      ModelField<ModelForRoute<this>>,
+      {},
+      null
+    >;
+  }
+}
+
+declare module '@ember/controller' {
+  export default interface Controller {
+    [Context]: TemplateContext<this, ModelField<this['model']>, {}, null>;
+  }
+}
+
+import type { LinkToComponent } from '../intrinsics/link-to';
+declare module '@ember/routing' {
+  export interface LinkTo extends LinkToComponent {}
+}
+
+//////////////////////////////////////////////////////////////////////
+// Rendering Tests
+
+import '@ember/test-helpers';
+
+type TestTemplate<T> = abstract new () => HasContext<TemplateContext<T, {}, {}, void>>;
+
+declare module '@ember/test-helpers' {
+  export function render<T>(template: TestTemplate<T>): Promise<void>;
+}
+
+import '@ember/modifier';
+import type { OnModifier as ImportedOnModifier } from '../intrinsics/on';
+declare module '@ember/modifier' {
+  export interface OnModifier extends ImportedOnModifier {}
+}
+
+import '@ember/helper';
+import type { ConcatHelper as ImportedConcatHelper } from '../intrinsics/concat';
+import type { FnHelper as ImportedFnHelper } from '../intrinsics/fn';
+import type { GetHelper as ImportedGetHelper } from '../intrinsics/get';
+
+declare module '@ember/helper' {
+  export interface ConcatHelper extends ImportedConcatHelper {}
+  export interface FnHelper extends ImportedFnHelper {}
+  export interface GetHelper extends ImportedGetHelper {}
+}
+
+}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/action.d.ts

@@ -0,0 +1,48 @@
+declare module '@glint/ember-tsc/-private/intrinsics/action' {
+import { DirectInvokable, NamedArgs } from '@glint/template/-private/integration';
+
+export type ActionNamedArgs<T> = NamedArgs<{
+  value?: keyof T;
+}>;
+
+export type ActionResult<T, Args extends ActionNamedArgs<T>> = undefined extends Args['value']
+  ? T
+  : Args['value'] extends keyof T
+    ? T[Args['value']]
+    : T;
+
+export type ActionKeyword = DirectInvokable<{
+  <Ret, Args extends ActionNamedArgs<Ret>, Params extends unknown[]>(
+    f: (...rest: Params) => Ret,
+    args?: Args,
+  ): (...rest: Params) => ActionResult<Ret, Args>;
+  <A, Ret, Args extends ActionNamedArgs<Ret>, Params extends unknown[]>(
+    f: (a: A, ...rest: Params) => Ret,
+    a: A,
+    args?: Args,
+  ): (...rest: Params) => ActionResult<Ret, Args>;
+  <A, B, Ret, Args extends ActionNamedArgs<Ret>, Params extends unknown[]>(
+    f: (a: A, b: B, ...rest: Params) => Ret,
+    a: A,
+    b: B,
+    args?: Args,
+  ): (...rest: Params) => ActionResult<Ret, Args>;
+  <A, B, C, Ret, Args extends ActionNamedArgs<Ret>, Params extends unknown[]>(
+    f: (a: A, b: B, c: C, ...rest: Params) => Ret,
+    a: A,
+    b: B,
+    c: C,
+    args?: Args,
+  ): (...rest: Params) => ActionResult<Ret, Args>;
+  <A, B, C, D, Ret, Args extends ActionNamedArgs<Ret>, Params extends unknown[]>(
+    f: (a: A, b: B, c: C, d: D, ...rest: Params) => Ret,
+    a: A,
+    b: B,
+    c: C,
+    d: D,
+    args?: Args,
+  ): (...rest: Params) => ActionResult<Ret, Args>;
+  (action: string, ...rest: unknown[]): (...rest: unknown[]) => unknown;
+}>;
+
+}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/concat.d.ts

@@ -0,0 +1,9 @@
+declare module '@glint/ember-tsc/-private/intrinsics/concat' {
+import { HelperLike } from '@glint/template';
+
+export type ConcatHelper = HelperLike<{
+  Args: { Positional: unknown[] };
+  Return: string;
+}>;
+
+}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/each-in.d.ts

@@ -0,0 +1,27 @@
+declare module '@glint/ember-tsc/-private/intrinsics/each-in' {
+import { ComponentLike } from '@glint/template';
+
+export type EachInKeyword = abstract new <T>() => InstanceType<
+  ComponentLike<{
+    Args: {
+      Positional: [object: T];
+      Named: { key?: string };
+    };
+    Blocks: {
+      default: EachInIteratorPair<T>;
+      else?: [];
+    };
+  }>
+>;
+
+type EachInIteratorPair<T> =
+  T extends Iterable<[infer K, infer V]>
+    ? [key: K, value: V]
+    : [key: EachInKey<T>, value: Exclude<T, null | undefined>[EachInKey<T>]];
+
+// `{{each-in}}` internally uses `Object.keys`, so only string keys are included
+// TS, on the other hand, gives a wider result for `keyof` than many users expect
+// for record types: https://github.com/microsoft/TypeScript/issues/29249
+type EachInKey<T> = Extract<keyof Exclude<T, null | undefined>, string>;
+
+}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/each.d.ts

@@ -0,0 +1,20 @@
+declare module '@glint/ember-tsc/-private/intrinsics/each' {
+import EmberArray from '@ember/array';
+import { ComponentLike } from '@glint/template';
+
+type ArrayLike<T> = ReadonlyArray<T> | Iterable<T> | EmberArray<T>;
+
+export type EachKeyword = abstract new <T = any>() => InstanceType<
+  ComponentLike<{
+    Args: {
+      Positional: [items: ArrayLike<T> | null | undefined];
+      Named: { key?: string };
+    };
+    Blocks: {
+      default: [T, number];
+      else: [];
+    };
+  }>
+>;
+
+}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/fn.d.ts

@@ -0,0 +1,47 @@
+declare module '@glint/ember-tsc/-private/intrinsics/fn' {
+import { DirectInvokable } from '@glint/template/-private/integration';
+import { Mut } from './mut';
+
+export type FnHelper = DirectInvokable<{
+  <T>(update: Mut<T>): (value: T) => void;
+  <T>(update: Mut<T>, value: T): () => void;
+  <Ret, Args extends unknown[]>(f: (...rest: Args) => Ret): (...rest: Args) => Ret;
+  <A, Ret, Args extends unknown[]>(f: (a: A, ...rest: Args) => Ret, a: A): (...rest: Args) => Ret;
+  <A, B, Ret, Args extends unknown[]>(
+    f: (a: A, b: B, ...rest: Args) => Ret,
+    a: A,
+    b: B,
+  ): (...rest: Args) => Ret;
+  <A, B, C, Ret, Args extends unknown[]>(
+    f: (a: A, b: B, c: C, ...rest: Args) => Ret,
+    a: A,
+    b: B,
+    c: C,
+  ): (...rest: Args) => Ret;
+  <A, B, C, D, Ret, Args extends unknown[]>(
+    f: (a: A, b: B, c: C, d: D, ...rest: Args) => Ret,
+    a: A,
+    b: B,
+    c: C,
+    d: D,
+  ): (...rest: Args) => Ret;
+  <A, B, C, D, E, Ret, Args extends unknown[]>(
+    f: (a: A, b: B, c: C, d: D, e: E, ...rest: Args) => Ret,
+    a: A,
+    b: B,
+    c: C,
+    d: D,
+    e: E,
+  ): (...rest: Args) => Ret;
+  <A, B, C, D, E, G, Ret, Args extends unknown[]>(
+    f: (a: A, b: B, c: C, d: D, e: E, g: G, ...rest: Args) => Ret,
+    a: A,
+    b: B,
+    c: C,
+    d: D,
+    e: E,
+    g: G,
+  ): (...rest: Args) => Ret;
+}>;
+
+}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/get.d.ts

@@ -0,0 +1,34 @@
+declare module '@glint/ember-tsc/-private/intrinsics/get' {
+import { DirectInvokable } from '@glint/template/-private/integration';
+import ObjectProxy from '@ember/object/proxy';
+import '@ember/object/-private/types';
+
+// This hack lets us support both the stable/preview types from `ember-source`
+// and the classic types still live on DefinitelyTyped. If using the DT types,
+// this acts as a declaration merge for a module which is then integrated via
+// the rest of the DT types. If using the stable/preview types, this ends up
+// being a no-op.
+declare const GetSetMarker: unique symbol;
+declare module '@ember/object/-private/types' {
+  interface ComputedPropertyMarker<Get, Set = Get> {
+    [GetSetMarker]: [Get, Set];
+  }
+}
+
+type UnwrapComputedPropertyGetter<T> = T extends { [GetSetMarker]: [infer U, any] } ? U : T;
+
+export type GetHelper = DirectInvokable<{
+  <T, K extends keyof T>(obj: T, key: K): UnwrapComputedPropertyGetter<T[K]>;
+  <T, K extends keyof T>(
+    obj: T | null | undefined,
+    key: K,
+  ): UnwrapComputedPropertyGetter<T[K]> | undefined;
+  <T extends object, K extends keyof T>(
+    obj: ObjectProxy<T> | null | undefined,
+    key: K,
+  ): UnwrapComputedPropertyGetter<T[K]> | undefined;
+  (obj: null | undefined, key: string): undefined;
+  (obj: unknown, key: string): unknown;
+}>;
+
+}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/input.d.ts

@@ -0,0 +1,24 @@
+import { ComponentLike } from '@glint/template';
+
+export interface CheckboxInputArgs {
+  type: 'checkbox';
+  checked?: boolean | undefined;
+}
+
+export interface TextInputArgs {
+  type?: string | undefined;
+  value?: string | null | undefined;
+  enter?: ((value: string, event: KeyboardEvent) => void) | undefined;
+  'insert-newline'?: ((value: string, event: KeyboardEvent) => void) | undefined;
+  'escape-press'?: ((value: string, event: KeyboardEvent) => void) | undefined;
+  'focus-in'?: ((value: string, event: FocusEvent) => void) | undefined;
+  'focus-out'?: ((value: string, event: FocusEvent) => void) | undefined;
+  'key-down'?: ((value: string, event: KeyboardEvent) => void) | undefined;
+  'key-press'?: ((value: string, event: KeyboardEvent) => void) | undefined;
+  'key-up'?: ((value: string, event: KeyboardEvent) => void) | undefined;
+}
+
+export type InputComponent = ComponentLike<{
+  Args: { Named: CheckboxInputArgs | TextInputArgs };
+  Element: HTMLInputElement;
+}>;

package/external-types/@glint__ember-tsc/types/-private/intrinsics/link-to.d.ts

@@ -0,0 +1,31 @@
+import { ComponentLike } from '@glint/template';
+import { ComponentReturn, DirectInvokable, NamedArgs } from '@glint/template/-private/integration';
+
+type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> &
+  {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+  }[Keys];
+
+type LinkToArgs = RequireAtLeastOne<
+  {
+    route?: string;
+    model?: unknown;
+    models?: unknown[];
+    query?: Record<string, unknown>;
+    disabled?: boolean;
+    activeClass?: string;
+    'current-when'?: string | boolean;
+    preventDefault?: boolean;
+    replace?: boolean;
+    tagName?: string;
+  },
+  'route' | 'model' | 'models' | 'query'
+>;
+
+type LinkToReturn = ComponentReturn<{ default: [] }, HTMLAnchorElement>;
+
+export type LinkToComponent = ComponentLike<{
+  Args: LinkToArgs;
+  Blocks: { default: [] };
+  Element: HTMLAnchorElement;
+}>;

package/external-types/@glint__ember-tsc/types/-private/intrinsics/log.d.ts

@@ -0,0 +1,9 @@
+declare module '@glint/ember-tsc/-private/intrinsics/log' {
+import { HelperLike } from '@glint/template';
+
+export type LogHelper = HelperLike<{
+  Args: { Positional: unknown[] };
+  Return: void;
+}>;
+
+}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/mount.d.ts

@@ -0,0 +1,12 @@
+declare module '@glint/ember-tsc/-private/intrinsics/mount' {
+import { HelperLike } from '@glint/template';
+
+export type MountKeyword = HelperLike<{
+  Args: {
+    Positional: [engine: string];
+    Named: { model?: unknown };
+  };
+  Return: void;
+}>;
+
+}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/mut.d.ts

@@ -0,0 +1,17 @@
+declare module '@glint/ember-tsc/-private/intrinsics/mut' {
+import { HelperLike } from '@glint/template';
+
+declare const Mut: unique symbol;
+
+export type Mut<T> = { [Mut]: (value: T) => void };
+
+export type MutKeyword = abstract new <T>() => InstanceType<
+  HelperLike<{
+    Args: {
+      Positional: [value: T];
+    };
+    Return: Mut<T>;
+  }>
+>;
+
+}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/on.d.ts

@@ -0,0 +1,24 @@
+declare module '@glint/ember-tsc/-private/intrinsics/on' {
+import { ModifierLike } from '@glint/template';
+
+export interface OnModifierArgs {
+  capture?: boolean;
+  once?: boolean;
+  passive?: boolean;
+}
+
+export type EventForName<Name extends string> = Name extends keyof HTMLElementEventMap
+  ? HTMLElementEventMap[Name]
+  : Event;
+
+export type OnModifier = abstract new <Name extends string>() => InstanceType<
+  ModifierLike<{
+    Element: Element;
+    Args: {
+      Named: OnModifierArgs;
+      Positional: [name: Name, callback: (event: EventForName<Name>) => void];
+    };
+  }>
+>;
+
+}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/outlet.d.ts

@@ -0,0 +1,11 @@
+declare module '@glint/ember-tsc/-private/intrinsics/outlet' {
+import { HelperLike } from '@glint/template';
+
+export type OutletKeyword = HelperLike<{
+  Args: {
+    Positional: [name?: string];
+  };
+  Return: void;
+}>;
+
+}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/textarea.d.ts

@@ -0,0 +1,16 @@
+import { ComponentLike } from '@glint/template';
+
+export interface TextareaArgs {
+  value?: string | null | undefined;
+  enter?: ((value: string, event: KeyboardEvent) => void) | undefined;
+  'insert-newline'?: ((value: string, event: KeyboardEvent) => void) | undefined;
+  'escape-press'?: ((value: string, event: KeyboardEvent) => void) | undefined;
+  'focus-in'?: ((value: string, event: FocusEvent) => void) | undefined;
+  'focus-out'?: ((value: string, event: FocusEvent) => void) | undefined;
+  'key-press'?: ((value: string, event: KeyboardEvent) => void) | undefined;
+}
+
+export type TextareaComponent = ComponentLike<{
+  Args: TextareaArgs;
+  Element: HTMLTextAreaElement;
+}>;

package/external-types/@glint__ember-tsc/types/-private/intrinsics/unbound.d.ts

@@ -0,0 +1,13 @@
+declare module '@glint/ember-tsc/-private/intrinsics/unbound' {
+import { HelperLike } from '@glint/template';
+
+export type UnboundKeyword = abstract new <T>() => InstanceType<
+  HelperLike<{
+    Args: {
+      Positional: [value: T];
+    };
+    Return: T;
+  }>
+>;
+
+}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/unique-id.d.ts

@@ -0,0 +1,8 @@
+declare module '@glint/ember-tsc/-private/intrinsics/unique-id' {
+import { HelperLike } from '@glint/template';
+
+export type UniqueIdHelper = HelperLike<{
+  Return: string;
+}>;
+
+}

package/external-types/@glint__ember-tsc/types/globals/index.d.ts

@@ -0,0 +1,6 @@
+declare module '@glint/ember-tsc/globals' {
+export default interface Globals {
+  // used to hang any macros off of that are provided by config.additionalGlobals
+}
+
+}

package/external-types/@glint__ember-tsc/types/silent-error.d.ts

@@ -0,0 +1,4 @@
+declare module 'silent-error' {
+  class SilentError extends Error {}
+  export default SilentError;
+}