@azure-tools/typespec-ts 0.54.0-dev.7 → 0.54.0-dev.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-tools/typespec-ts",
-  "version": "0.54.0-dev.7",
+  "version": "0.54.0-dev.8",
   "description": "An experimental TypeSpec emitter for TypeScript RLC",
   "main": "dist/src/index.js",
   "type": "module",

package/src/index.ts

@@ -298,6 +298,34 @@ export async function $onEmit(context: EmitContext) {
         dpgContext.generationPathDetail?.metadataDir,
       );
     }
+    // The binder is only resolved in the modular path, so static helper files
+    // loaded into the outputProject are never written to disk in the RLC path.
+    // The RLC builders reference the platform-types helper (NodeReadableStream),
+    // so emit those files here.
+    await emitRLCStaticHelpers();
+  }
+
+  async function emitRLCStaticHelpers() {
+    if (program.compilerOptions.noEmit || program.hasError() || !rlcCodeModels[0]) {
+      return;
+    }
+    const project = useContext("outputProject");
+    for (const helperFile of project.getSourceFiles()) {
+      const filePath = helperFile.getFilePath();
+      // RLC builders (buildParameterTypes / buildSchemaType) only reference
+      // platform-types (and its browser/react-native variants); emit those
+      // files directly under src/ (strip the static-helpers/ segment) to match
+      // the RLC design where all generated output lives in src/.
+      if (!basename(filePath).startsWith("platform-types")) {
+        continue;
+      }
+      const outputPath = filePath.replace(/\/static-helpers\//g, "/");
+      await emitContentByBuilder(
+        program,
+        () => ({ content: helperFile.getFullText(), path: outputPath }),
+        rlcCodeModels[0],
+      );
+    }
   }
 
   async function generateModularSources() {

package/src/rlc-common/buildObjectTypes.ts

@@ -527,8 +527,8 @@ function getPropertySignatures(
 function isBinaryArray(schema: Schema): boolean {
   return Boolean(
     isArraySchema(schema) &&
-    (schema.items?.typeName?.includes("NodeJS.ReadableStream") ||
-      schema.items?.outputTypeName?.includes("NodeJS.ReadableStream")),
+    (schema.items?.typeName?.includes("NodeReadableStream") ||
+      schema.items?.outputTypeName?.includes("NodeReadableStream")),
   );
 }
 

package/src/rlc-common/buildParameterTypes.ts

@@ -169,6 +169,30 @@ export function buildParameterTypes(model: RLCModel) {
       },
     ]);
   }
+  // Add NodeReadableStream import if binary types are used in parameters.
+  // platform-types.ts is generated directly under src/ (no static-helpers/
+  // subdirectory) to match the RLC design where all output lives in src/.
+  // The platform-types static helper resolves NodeReadableStream to
+  // NodeJS.ReadableStream on Node and `never` on browser/react-native, so the
+  // union arm drops out naturally in non-Node builds.
+  if (parametersFile.getFullText().includes("NodeReadableStream")) {
+    const platformTypesModuleSpecifier = model.options?.azureSdkForJs
+      ? "#platform/platform-types"
+      : getImportModuleName(
+          {
+            cjsName: `./platform-types`,
+            esModulesName: `./platform-types.js`,
+          },
+          model,
+        );
+    parametersFile.addImportDeclarations([
+      {
+        isTypeOnly: true,
+        namedImports: ["NodeReadableStream"],
+        moduleSpecifier: platformTypesModuleSpecifier,
+      },
+    ]);
+  }
   return { path: filePath, content: parametersFile.getFullText() };
 }
 

package/src/rlc-common/buildSchemaType.ts

@@ -9,6 +9,7 @@ import {
   buildPolymorphicAliases,
 } from "./buildObjectTypes.js";
 import { getImportSpecifier } from "./helpers/importsUtil.js";
+import { getImportModuleName } from "./helpers/nameConstructors.js";
 import { RLCModel, SchemaContext } from "./interfaces.js";
 
 /**
@@ -58,6 +59,30 @@ export function generateModelFiles(
         },
       ]);
     }
+    // Add NodeReadableStream import if binary types are used in models.
+    // platform-types.ts is generated directly under src/ (no static-helpers/
+    // subdirectory) to match the RLC design where all output lives in src/.
+    // The platform-types static helper resolves NodeReadableStream to
+    // NodeJS.ReadableStream on Node and `never` on browser/react-native, so the
+    // union arm drops out naturally in non-Node builds.
+    if (modelsFile.getFullText().includes("NodeReadableStream")) {
+      const platformTypesModuleSpecifier = model.options?.azureSdkForJs
+        ? "#platform/platform-types"
+        : getImportModuleName(
+            {
+              cjsName: `./platform-types`,
+              esModulesName: `./platform-types.js`,
+            },
+            model,
+          );
+      modelsFile.addImportDeclarations([
+        {
+          isTypeOnly: true,
+          namedImports: ["NodeReadableStream"],
+          moduleSpecifier: platformTypesModuleSpecifier,
+        },
+      ]);
+    }
     return { path: filePath, content: modelsFile.getFullText() };
   }
   return undefined;

package/src/utils/modelUtils.ts

@@ -81,7 +81,7 @@ import { reportDiagnostic } from "../lib.js";
 import { getModelNamespaceName } from "./namespaceUtils.js";
 
 export const BINARY_TYPE_UNION =
-  "string | Uint8Array | ReadableStream<Uint8Array> | NodeJS.ReadableStream";
+  "string | Uint8Array | ReadableStream<Uint8Array> | NodeReadableStream";
 
 export const BINARY_AND_FILE_TYPE_UNION = `${BINARY_TYPE_UNION} | File`;