@typespec/emitter-framework 0.10.0 → 0.11.0-dev.1

package/dist/test/typescript/test-host.js

@@ -1,15 +1,6 @@
 import { createTestHost, createTestWrapper, expectDiagnosticEmpty } from "@typespec/compiler/testing";
-import { HttpTestLibrary } from "@typespec/http/testing";
-export async function createTypespecCliTestHost(options = {
-  libraries: []
-}) {
-  const libraries = [];
-  if (options.libraries.includes("Http")) {
-    libraries.push(HttpTestLibrary);
-  }
-  return createTestHost({
-    libraries
-  });
+export async function createTypespecCliTestHost() {
+  return createTestHost({});
 }
 export async function createEmitterFrameworkTestRunner(options = {}) {
   const host = await createTypespecCliTestHost();
@@ -17,10 +8,8 @@ export async function createEmitterFrameworkTestRunner(options = {}) {
     autoUsings: options.autoUsings
   });
 }
-export async function getProgram(code, options = {
-  libraries: []
-}) {
-  const host = await createTypespecCliTestHost(options);
+export async function getProgram(code) {
+  const host = await createTypespecCliTestHost();
   const wrapper = createTestWrapper(host, {
     compilerOptions: {
       noEmit: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typespec/emitter-framework",
-  "version": "0.10.0",
+  "version": "0.11.0-dev.1",
   "type": "module",
   "main": "dist/index.js",
   "repository": {
@@ -44,15 +44,14 @@
     "@alloy-js/core": "^0.19.0",
     "@alloy-js/csharp": "^0.19.0",
     "@alloy-js/typescript": "^0.19.0",
-    "@typespec/compiler": "^1.3.0",
-    "@typespec/rest": "^0.73.0",
-    "@typespec/http": "^1.3.0"
+    "@typespec/compiler": "^1.3.0"
   },
   "devDependencies": {
     "@alloy-js/cli": "^0.19.0",
     "@alloy-js/core": "^0.19.0",
     "@alloy-js/rollup-plugin": "^0.1.0",
     "@alloy-js/typescript": "^0.19.0",
+    "@typespec/compiler": "^1.3.0",
     "concurrently": "^9.1.2",
     "pathe": "^2.0.3",
     "prettier": "~3.6.2",
@@ -63,11 +62,9 @@
     "tree-sitter-typescript": "^0.23.0",
     "typescript": "~5.8.2",
     "vitest": "^3.1.2",
-    "web-tree-sitter": "^0.25.4",
-    "@typespec/compiler": "^1.3.0",
-    "@typespec/http": "^1.3.0",
-    "@typespec/rest": "^0.73.0"
+    "web-tree-sitter": "^0.25.4"
   },
+  "dependencies": {},
   "scripts": {
     "build": "alloy build",
     "clean": "rimraf ./dist",

package/src/core/components/index.tsx

@@ -1 +1,3 @@
 export * from "./output.jsx";
+export * from "./overrides/component-overrides.jsx";
+export * from "./overrides/config.js";

package/src/core/components/overrides/component-overrides.tsx

@@ -0,0 +1,134 @@
+import { type Children, type ComponentDefinition } from "@alloy-js/core";
+import type { ObjectPropertyProps, VarDeclarationProps } from "@alloy-js/typescript";
+import type {
+  Enum,
+  EnumMember,
+  Model,
+  ModelProperty,
+  Scalar,
+  Type,
+  Union,
+  UnionVariant,
+} from "@typespec/compiler";
+import { useTsp } from "../../context/index.js";
+import {
+  type Experimental_ComponentOverridesConfig,
+  getOverrideForType,
+  getOverridesForTypeKind,
+} from "./config.js";
+import { type ComponentOverridesContext, OverridesContext, useOverrides } from "./context.js";
+
+export interface Experimental_OverrideEmitPropsBase<TCustomType extends Type> {
+  /**
+   * The TypeSpec type to render.
+   */
+  type: TCustomType;
+
+  /**
+   * The default emitted output for this type.
+   */
+  default: Children;
+}
+
+export type Experimental_CustomTypeToProps<TCustomType extends Type> =
+  TCustomType extends ModelProperty
+    ? ObjectPropertyProps
+    : TCustomType extends EnumMember
+      ? {}
+      : TCustomType extends UnionVariant
+        ? {}
+        : TCustomType extends Model | Scalar | Union | Enum
+          ? VarDeclarationProps
+          : VarDeclarationProps | ObjectPropertyProps;
+
+export interface Experimental_OverrideReferenceProps<TCustomType extends Type>
+  extends Experimental_OverrideEmitPropsBase<TCustomType> {
+  /**
+   * The member this type is referenced from, if any. This member may contain
+   * additional metadata that should be represented in the emitted output.
+   */
+  member?: ModelProperty;
+}
+
+export interface Experimental_OverrideDeclareProps<TCustomType extends Type>
+  extends Experimental_OverrideEmitPropsBase<TCustomType> {
+  Declaration: ComponentDefinition<Experimental_CustomTypeToProps<TCustomType>>;
+  declarationProps: Experimental_CustomTypeToProps<TCustomType>;
+}
+
+export type Experimental_OverrideDeclarationComponent<TCustomType extends Type> =
+  ComponentDefinition<Experimental_OverrideDeclareProps<TCustomType>>;
+
+export type Experimental_OverrideReferenceComponent<TCustomType extends Type> = ComponentDefinition<
+  Experimental_OverrideReferenceProps<TCustomType>
+>;
+
+export interface Experimental_ComponentOverridesConfigBase<TCustomType extends Type> {
+  /**
+   * Override when this type is referenced.
+   * e.g. When used in <TypeExpression type={type} />
+   */
+  reference?: Experimental_OverrideReferenceComponent<TCustomType>;
+}
+
+export interface Experimental_ComponentOverridesProps {
+  overrides: Experimental_ComponentOverridesConfig;
+  children?: Children;
+}
+export function Experimental_ComponentOverrides(props: Experimental_ComponentOverridesProps) {
+  const context: ComponentOverridesContext = {
+    overrides: props.overrides,
+  };
+
+  return <OverridesContext.Provider value={context}>{props.children}</OverridesContext.Provider>;
+}
+
+export interface Experimental_OverrideTypeComponentCommonProps<T extends Type> {
+  /**
+   * The TypeSpec type to render.
+   */
+  type: T;
+
+  /**
+   * The default rendering.
+   */
+  children: Children;
+}
+
+export interface Experimental_OverridableComponentReferenceProps<T extends Type>
+  extends Experimental_OverrideTypeComponentCommonProps<T> {
+  /**
+   * Pass when rendering a reference to the provided type or type kind.
+   */
+  reference: true;
+
+  /**
+   * The member this type is referenced from, if any. This member may contain
+   * additional metadata that should be represented in the emitted output.
+   */
+  member?: ModelProperty;
+}
+
+export type Experimental_OverridableComponentProps<T extends Type> =
+  Experimental_OverridableComponentReferenceProps<T>;
+
+export function Experimental_OverridableComponent<T extends Type>(
+  props: Experimental_OverridableComponentProps<T>,
+) {
+  const options = useOverrides();
+  const { $ } = useTsp();
+  const descriptor =
+    getOverrideForType($.program, props.type, options.overrides) ??
+    getOverridesForTypeKind($.program, props.type.kind, options.overrides);
+
+  if (!descriptor) {
+    return <>{props.children}</>;
+  }
+
+  if ("reference" in props && props.reference && descriptor.reference) {
+    const CustomComponent = descriptor.reference;
+    return <CustomComponent type={props.type} member={props.member} default={props.children} />;
+  }
+
+  return <>{props.children}</>;
+}

package/src/core/components/overrides/config.ts

@@ -0,0 +1,85 @@
+import type { Program, Scalar, Type } from "@typespec/compiler";
+import { $ } from "@typespec/compiler/typekit";
+import type { Experimental_ComponentOverridesConfigBase } from "./component-overrides.jsx";
+
+const getOverrideForTypeSym: unique symbol = Symbol.for("ef-ts:getOverrideForType");
+const getOverrideForTypeKindSym: unique symbol = Symbol.for("ef-ts:getOverrideForTypeKind");
+
+export type Experimental_ComponentOverridesConfig = Experimental_ComponentOverridesClass;
+export const Experimental_ComponentOverridesConfig = function () {
+  return new Experimental_ComponentOverridesClass();
+} as {
+  new (): Experimental_ComponentOverridesClass;
+  (): Experimental_ComponentOverridesClass;
+};
+
+export class Experimental_ComponentOverridesClass {
+  #typeEmitOptions: Map<Type, Experimental_ComponentOverridesConfigBase<any>> = new Map();
+  #typeKindEmitOptions: Map<Type["kind"], Experimental_ComponentOverridesConfigBase<any>> =
+    new Map();
+
+  forType<const T extends Type>(type: T, options: Experimental_ComponentOverridesConfigBase<T>) {
+    this.#typeEmitOptions.set(type, options);
+
+    return this;
+  }
+
+  forTypeKind<const TKind extends Type["kind"]>(
+    typeKind: TKind,
+    options: Experimental_ComponentOverridesConfigBase<Extract<Type, { kind: TKind }>>,
+  ) {
+    this.#typeKindEmitOptions.set(typeKind, options);
+
+    return this;
+  }
+
+  /**
+   * @internal
+   */
+  [getOverrideForTypeSym](program: Program, type: Type) {
+    const options = this.#typeEmitOptions.get(type);
+    if (options || !$(program).scalar.is(type) /** || isBuiltIn(program, type) */) {
+      return options;
+    }
+
+    // have a scalar, it's not a built-in scalar, and didn't find options, so
+    // see if we have options for a base scalar.
+    let currentScalar: Scalar | undefined = type;
+    while (
+      currentScalar &&
+      // !isBuiltIn(program, currentScalar) &&
+      !this.#typeEmitOptions.has(currentScalar)
+    ) {
+      currentScalar = currentScalar?.baseScalar;
+    }
+
+    if (!currentScalar) {
+      return undefined;
+    }
+
+    return this.#typeEmitOptions.get(currentScalar);
+  }
+
+  /**
+   * @internal
+   */
+  [getOverrideForTypeKindSym](program: Program, typeKind: Type["kind"]) {
+    return this.#typeKindEmitOptions.get(typeKind);
+  }
+}
+
+export function getOverrideForType(
+  program: Program,
+  type: Type,
+  options?: Experimental_ComponentOverridesConfig,
+) {
+  return options?.[getOverrideForTypeSym](program, type);
+}
+
+export function getOverridesForTypeKind(
+  program: Program,
+  typeKind: Type["kind"],
+  options?: Experimental_ComponentOverridesConfig,
+) {
+  return options?.[getOverrideForTypeKindSym](program, typeKind);
+}

package/src/core/components/overrides/context.ts

@@ -0,0 +1,14 @@
+import { createContext, useContext, type ComponentContext } from "@alloy-js/core";
+import type { Experimental_ComponentOverridesConfig } from "./config.js";
+
+export interface ComponentOverridesContext {
+  overrides?: Experimental_ComponentOverridesConfig;
+}
+/**
+ * Context for setting overrides for components
+ */
+export const OverridesContext: ComponentContext<ComponentOverridesContext> = createContext({});
+
+export function useOverrides(): ComponentOverridesContext {
+  return useContext(OverridesContext)!;
+}

package/src/csharp/components/class/declaration.test.tsx

@@ -1,5 +1,10 @@
+import {
+  Experimental_ComponentOverrides,
+  Experimental_ComponentOverridesConfig,
+} from "#core/index.js";
 import { Tester } from "#test/test-host.js";
-import { type Children } from "@alloy-js/core";
+import { List, type Children } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
 import { createCSharpNamePolicy, Namespace, SourceFile } from "@alloy-js/csharp";
 import { t, type TesterInstance } from "@typespec/compiler/testing";
 import { beforeEach, describe, expect, it } from "vitest";
@@ -67,6 +72,65 @@ it("renders a class declaration with properties", async () => {
   `);
 });
 
+it("renders a class declaration with properties using component override", async () => {
+  const { TestModel, Foo, Bar } = await runner.compile(t.code`
+    model ${t.model("Foo")} {}
+    model ${t.model("Bar")} {}
+    model ${t.model("TestModel")} {
+      Prop1: string;
+      Prop2: int32;
+      Prop3?: Foo;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <TestClientOverrides>
+        <List hardline>
+          <ClassDeclaration type={Foo} />
+          <ClassDeclaration type={Bar} />
+          <ClassDeclaration type={TestModel} />
+        </List>
+      </TestClientOverrides>
+    </Wrapper>,
+  ).toRenderTo(d`
+    namespace TestNamespace
+    {
+        class Foo
+        {
+
+        }
+        class Bar
+        {
+
+        }
+        class TestModel
+        {
+            public required string Prop1 { get; set; }
+            public required int Prop2 { get; set; }
+            public Bar Prop3 { get; set; }
+        }
+    }
+  `);
+});
+
+function TestClientOverrides(props: { children?: Children }) {
+  const overrides = Experimental_ComponentOverridesConfig().forTypeKind("Model", {
+    reference: (props) => {
+      if (props.type.name === "Foo") {
+        return "Bar";
+      } else {
+        return props.default;
+      }
+    },
+  });
+  return (
+    <Experimental_ComponentOverrides overrides={overrides}>
+      {props.children}
+    </Experimental_ComponentOverrides>
+  );
+}
+
 it("can override class name", async () => {
   const { TestModel } = await runner.compile(t.code`
     model ${t.model("TestModel")} {}

package/src/csharp/components/type-expression.tsx

@@ -1,3 +1,4 @@
+import { Experimental_OverridableComponent } from "#core/index.js";
 import { type Children, code } from "@alloy-js/core";
 import { Reference } from "@alloy-js/csharp";
 import { getTypeName, type IntrinsicType, type Scalar, type Type } from "@typespec/compiler";
@@ -13,7 +14,11 @@ export interface TypeExpressionProps {
 export function TypeExpression(props: TypeExpressionProps): Children {
   const { $ } = useTsp();
   if (isDeclaration($, props.type)) {
-    return <Reference refkey={efRefkey(props.type)} />;
+    return (
+      <Experimental_OverridableComponent reference type={props.type}>
+        <Reference refkey={efRefkey(props.type)} />
+      </Experimental_OverridableComponent>
+    );
   }
   if ($.scalar.is(props.type)) {
     return getScalarIntrinsicExpression($, props.type);

package/src/testing/scenario-test/harness.ts

@@ -198,7 +198,12 @@ function describeScenarios(
               );
 
               if (SCENARIOS_UPDATE) {
-                testBlock.content = await languageConfiguration.format(result);
+                try {
+                  testBlock.content = await languageConfiguration.format(result);
+                } catch {
+                  // If formatting fails, we still want to update the content
+                  testBlock.content = result;
+                }
               } else {
                 const expected = await languageConfiguration.format(testBlock.content);
                 const actual = await languageConfiguration.format(result);

package/src/typescript/components/interface-member.tsx

@@ -1,7 +1,6 @@
 import { type Children } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
 import { isNeverType, type ModelProperty, type Operation } from "@typespec/compiler";
-import { getHttpPart } from "@typespec/http";
 import { useTsp } from "../../core/context/tsp-context.js";
 import { InterfaceMethod } from "./interface-method.jsx";
 import { TypeExpression } from "./type-expression.js";
@@ -23,20 +22,15 @@ export function InterfaceMember(props: InterfaceMemberProps) {
       return null;
     }
 
-    let unpackedType = props.type.type;
-    const part = getHttpPart($.program, props.type.type);
-    if (part) {
-      unpackedType = part.type;
-    }
+    const unpackedType = props.type.type;
 
-    return (
-      <ts.InterfaceMember
-        doc={doc}
-        name={name}
-        optional={props.optional ?? props.type.optional}
-        type={<TypeExpression type={unpackedType} />}
-      />
-    );
+    const interfaceMemberProps = {
+      doc,
+      name,
+      optional: props.optional ?? props.type.optional,
+      type: <TypeExpression type={unpackedType} />,
+    };
+    return <ts.InterfaceMember {...interfaceMemberProps} />;
   }
 
   if ($.operation.is(props.type)) {

package/src/typescript/components/type-expression.tsx

@@ -2,7 +2,7 @@ import { For } from "@alloy-js/core";
 import { Reference, ValueExpression } from "@alloy-js/typescript";
 import type { IntrinsicType, Model, Scalar, Type } from "@typespec/compiler";
 import type { Typekit } from "@typespec/compiler/typekit";
-import "@typespec/http/experimental/typekit";
+import { Experimental_OverridableComponent } from "../../core/components/overrides/component-overrides.jsx";
 import { useTsp } from "../../core/context/tsp-context.js";
 import { reportTypescriptDiagnostic } from "../../typescript/lib.js";
 import { efRefkey } from "../utils/refkey.js";
@@ -25,11 +25,15 @@ export interface TypeExpressionProps {
 
 export function TypeExpression(props: TypeExpressionProps) {
   const { $ } = useTsp();
-  const type = $.httpPart.unpack(props.type);
+  const type = props.type;
   if (!props.noReference && isDeclaration($, type)) {
     // todo: probably need abstraction around deciding what's a declaration in the output
     // (it may not correspond to things which are declarations in TypeSpec?)
-    return <Reference refkey={efRefkey(type)} />;
+    return (
+      <Experimental_OverridableComponent reference type={type}>
+        <Reference refkey={efRefkey(type)} />
+      </Experimental_OverridableComponent>
+    );
     //throw new Error("Reference not implemented");
   }
 
@@ -69,11 +73,6 @@ export function TypeExpression(props: TypeExpressionProps) {
         return <RecordExpression elementType={elementType} />;
       }
 
-      if ($.httpPart.is(type)) {
-        const partType = $.httpPart.unpack(type);
-        return <TypeExpression type={partType} />;
-      }
-
       return <InterfaceExpression type={type} />;
     case "Operation":
       return <FunctionType type={type} />;

package/src/typescript/components/type-transform.tsx

@@ -227,7 +227,7 @@ export function ModelTransformExpression(props: ModelTransformExpressionProps) {
       {mapJoin(
         () => modelProperties,
         (_, property) => {
-          const unpackedType = $.httpPart.unpack(property.type) ?? property.type;
+          const unpackedType = property.type;
           let targetPropertyName = property.name;
           let sourcePropertyName = namePolicy.getName(property.name, "interface-member");
 
@@ -368,9 +368,7 @@ export function TypeTransformCall(props: TypeTransformCallProps): Children {
   }
   const transformType = collapsedProperty?.type ?? props.type;
   if ($.model.is(transformType) && $.array.is(transformType)) {
-    const unpackedElement =
-      $.httpPart.unpack($.array.getElementType(transformType)) ??
-      $.array.getElementType(transformType);
+    const unpackedElement = $.array.getElementType(transformType);
     return (
       <ts.FunctionCallExpression
         target={ArraySerializerRefkey}
@@ -380,9 +378,7 @@ export function TypeTransformCall(props: TypeTransformCallProps): Children {
   }
 
   if ($.model.is(transformType) && $.record.is(transformType)) {
-    const unpackedElement =
-      $.httpPart.unpack($.record.getElementType(transformType)) ??
-      $.record.getElementType(transformType);
+    const unpackedElement = $.record.getElementType(transformType);
     return (
       <ts.FunctionCallExpression
         target={RecordSerializerRefkey}

package/test/typescript/components/component-override.test.tsx

@@ -0,0 +1,71 @@
+import {
+  Experimental_ComponentOverrides,
+  Experimental_ComponentOverridesConfig,
+} from "#core/index.js";
+import { FunctionDeclaration } from "#typescript/index.js";
+import { For, List, type Children } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { SourceFile } from "@alloy-js/typescript";
+import type { Namespace } from "@typespec/compiler";
+import { expect, it } from "vitest";
+import { Output } from "../../../src/core/components/output.jsx";
+import { InterfaceDeclaration } from "../../../src/typescript/components/interface-declaration.jsx";
+import { Tester } from "../../test-host.js";
+
+it("uses overridden component", async () => {
+  const { program } = await Tester.compile(`
+          namespace DemoService;
+          model Foo {
+            knownProp: string;
+          }
+
+          op foo(): Foo;
+
+          `);
+
+  const [namespace] = program.resolveTypeReference("DemoService");
+  const models = Array.from((namespace as Namespace).models.values());
+  const operations = Array.from((namespace as Namespace).operations.values());
+
+  expect(
+    <Output program={program}>
+      <TestClientOverrides>
+        <SourceFile path="test.ts">
+          <List hardline>
+            {models.map((model) => (
+              <InterfaceDeclaration export type={model} />
+            ))}
+          </List>
+          <hbr />
+          <For each={operations}>
+            {(operation) => <FunctionDeclaration export type={operation} />}
+          </For>
+        </SourceFile>
+      </TestClientOverrides>
+    </Output>,
+  ).toRenderTo(
+    d`
+      export interface Foo {
+        knownProp: string;
+      }
+      export function foo(): unknown {}
+            `,
+  );
+});
+
+function TestClientOverrides(props: { children?: Children }) {
+  const overrides = Experimental_ComponentOverridesConfig().forTypeKind("Model", {
+    reference: (props) => {
+      if (props.type.name === "Foo") {
+        return "unknown";
+      } else {
+        return props.default;
+      }
+    },
+  });
+  return (
+    <Experimental_ComponentOverrides overrides={overrides}>
+      {props.children}
+    </Experimental_ComponentOverrides>
+  );
+}

package/test/typescript/test-host.ts

@@ -4,18 +4,9 @@ import {
   createTestWrapper,
   expectDiagnosticEmpty,
 } from "@typespec/compiler/testing";
-import { HttpTestLibrary } from "@typespec/http/testing";
 
-export async function createTypespecCliTestHost(
-  options: { libraries: "Http"[] } = { libraries: [] },
-) {
-  const libraries = [];
-  if (options.libraries.includes("Http")) {
-    libraries.push(HttpTestLibrary);
-  }
-  return createTestHost({
-    libraries,
-  });
+export async function createTypespecCliTestHost() {
+  return createTestHost({});
 }
 
 export async function createEmitterFrameworkTestRunner(options: { autoUsings?: string[] } = {}) {
@@ -25,11 +16,8 @@ export async function createEmitterFrameworkTestRunner(options: { autoUsings?: s
   });
 }
 
-export async function getProgram(
-  code: string,
-  options: { libraries: "Http"[] } = { libraries: [] },
-): Promise<Program> {
-  const host = await createTypespecCliTestHost(options);
+export async function getProgram(code: string): Promise<Program> {
+  const host = await createTypespecCliTestHost();
   const wrapper = createTestWrapper(host, {
     compilerOptions: {
       noEmit: true,