@azure-tools/typespec-ts 0.55.0-dev.1 → 0.55.0-dev.3

package/package.json

@@ -1,32 +1,32 @@
 {
   "name": "@azure-tools/typespec-ts",
-  "version": "0.55.0-dev.1",
+  "version": "0.55.0-dev.3",
   "description": "An experimental TypeSpec emitter for TypeScript RLC",
   "main": "dist/src/index.js",
   "type": "module",
   "exports": {
     ".": {
-      "default": "./dist/src/index.js",
-      "types": "./dist/src/index.d.ts"
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
     },
     "./testing": {
-      "default": "./dist/src/testing/index.js",
-      "types": "./dist/src/testing/index.d.ts"
+      "types": "./dist/src/testing/index.d.ts",
+      "default": "./dist/src/testing/index.js"
     }
   },
   "author": "Jose Heredia <joheredi@microsoft.com>",
   "license": "MIT",
   "devDependencies": {
     "@azure-rest/core-client": "^2.3.1",
-    "@typespec/http-specs": "^0.1.0-alpha.37 || >=0.1.0-alpha.38-dev <0.1.0-alpha.38",
+    "@typespec/http-specs": "^0.1.0-alpha.38 || >=0.1.0-alpha.39-dev <0.1.0-alpha.39",
     "@typespec/spector": "^0.1.0-alpha.25 || >=0.1.0-alpha.26-dev <0.1.0-alpha.26",
     "@typespec/spec-api": "^0.1.0-alpha.14 || >=0.1.0-alpha.15-dev <0.1.0-alpha.15",
-    "@typespec/tspd": "^0.74.2 || >=0.75.0-dev <0.75.0",
-    "@azure-tools/azure-http-specs": "^0.1.0-alpha.40 || >=0.1.0-alpha.41-dev <0.1.0-alpha.41",
-    "@azure-tools/typespec-autorest": "^0.68.0 || >=0.69.0-dev <0.69.0",
-    "@azure-tools/typespec-azure-core": "^0.68.0 || >=0.69.0-dev <0.69.0",
-    "@azure-tools/typespec-azure-resource-manager": "^0.68.0 || >=0.69.0-dev <0.69.0",
-    "@azure-tools/typespec-client-generator-core": "^0.68.4 || >=0.69.0-dev <0.69.0",
+    "@typespec/tspd": "^0.75.0 || >=0.76.0-dev <0.76.0",
+    "@azure-tools/azure-http-specs": "^0.1.0-alpha.42 || >=0.1.0-alpha.43-dev <0.1.0-alpha.43",
+    "@azure-tools/typespec-autorest": "^0.69.0 || >=0.70.0-dev <0.70.0",
+    "@azure-tools/typespec-azure-core": "^0.69.0 || >=0.70.0-dev <0.70.0",
+    "@azure-tools/typespec-azure-resource-manager": "^0.69.0 || >=0.70.0-dev <0.70.0",
+    "@azure-tools/typespec-client-generator-core": "^0.69.0 || >=0.70.0-dev <0.70.0",
     "@azure/abort-controller": "^2.1.2",
     "@azure/core-auth": "^1.6.0",
     "@azure/core-lro": "^3.1.0",
@@ -34,17 +34,14 @@
     "@azure/core-rest-pipeline": "^1.14.0",
     "@azure/core-util": "^1.4.0",
     "@azure/logger": "^1.0.4",
-    "@typescript-eslint/eslint-plugin": "^8.28.0",
-    "@typescript-eslint/parser": "^8.58.1",
-    "@typespec/compiler": "^1.12.0",
-    "@typespec/http": "^1.12.0",
-    "@typespec/openapi": "^1.12.0",
-    "@typespec/rest": "^0.82.0 || >=0.83.0-dev <0.83.0",
-    "@typespec/versioning": "^0.82.0 || >=0.83.0-dev <0.83.0",
-    "@typespec/xml": "^0.82.0 || >=0.83.0-dev <0.83.0",
+    "@typespec/compiler": "^1.13.0",
+    "@typespec/http": "^1.13.0",
+    "@typespec/openapi": "^1.13.0",
+    "@typespec/rest": "^0.83.0 || >=0.84.0-dev <0.84.0",
+    "@typespec/versioning": "^0.83.0 || >=0.84.0-dev <0.84.0",
+    "@typespec/xml": "^0.83.0 || >=0.84.0-dev <0.84.0",
     "@typespec/ts-http-runtime": "0.3.5",
     "cross-env": "^10.1.0",
-    "eslint-plugin-require-extensions": "0.1.3",
     "mkdirp": "^3.0.1",
     "npm-run-all": "~4.1.5",
     "prettier": "^3.8.1",
@@ -56,13 +53,13 @@
     "yaml": "^2.8.3"
   },
   "peerDependencies": {
-    "@azure-tools/typespec-azure-core": "^0.68.0 || >=0.69.0-dev <0.69.0",
-    "@azure-tools/typespec-client-generator-core": "^0.68.4 || >=0.69.0-dev <0.69.0",
-    "@typespec/compiler": "^1.12.0",
-    "@typespec/http": "^1.12.0",
-    "@typespec/rest": "^0.82.0 || >=0.83.0-dev <0.83.0",
-    "@typespec/versioning": "^0.82.0 || >=0.83.0-dev <0.83.0",
-    "@typespec/xml": "^0.82.0 || >=0.83.0-dev <0.83.0"
+    "@azure-tools/typespec-azure-core": "^0.69.0 || >=0.70.0-dev <0.70.0",
+    "@azure-tools/typespec-client-generator-core": "^0.69.0 || >=0.70.0-dev <0.70.0",
+    "@typespec/compiler": "^1.13.0",
+    "@typespec/http": "^1.13.0",
+    "@typespec/rest": "^0.83.0 || >=0.84.0-dev <0.84.0",
+    "@typespec/versioning": "^0.83.0 || >=0.84.0-dev <0.84.0",
+    "@typespec/xml": "^0.83.0 || >=0.84.0-dev <0.84.0"
   },
   "dependencies": {
     "fast-xml-parser": "^5.7.0",
@@ -95,11 +92,10 @@
     "test": "npm run test-next && npm run unit-test && npm run integration-test-ci",
     "test:azure": "npm run test-next && npm run copy:typespec && npm run integration-test-ci:azure-rlc && npm run integration-test-ci:azure-modular",
     "test:standard": "npm run test-next && npm run copy:typespec && npm run unit-test&& npm run integration-test-ci:rlc && npm run integration-test-ci:modular",
-    "lint": "eslint src --ext .ts --max-warnings=0",
-    "lint:fix": "eslint src --fix --ext .ts",
+    "lint": "eslint . --ext .ts --max-warnings=0",
+    "lint:fix": "eslint . --fix --ext .ts",
     "check:tree": "tsx ./test/commands/check-clean-tree.ts",
     "test:ts:e2e": "npm run copy:typespec && npm run integration-test-ci:azure-rlc && npm run integration-test-ci:azure-modular",
-    "prettier": "prettier --config ./.prettierrc \"{src,test,static}/**/*.ts\" \"!test/**/generated/**/*.ts\"",
     "integration-test-ci": "npm-run-all copy:typespec integration-test-ci:rlc integration-test-ci:azure-rlc integration-test-ci:modular integration-test-ci:azure-modular",
     "integration-test-ci:sequential": "npm-run-all --serial copy:typespec integration-test-ci:modular && npm run integration-test-ci:modular",
     "integration-test-ci:rlc": "npm-run-all --silent -p start-test-server:rlc --race generate-and-run:rlc",
@@ -131,6 +127,6 @@
     "unit-test": "npm-run-all --parallel unit-test:rlc unit-test:modular",
     "unit-test:rlc": "vitest run --project unit-rlc",
     "unit-test:modular": "cross-env NODE_OPTIONS=--max-old-space-size=8192 vitest run --project unit-modular",
-    "regen-docs": "npm run build && tspd doc . --enable-experimental --output-dir ./website/src/content/docs/docs/emitters/clients/typespec-ts/reference --skip-js"
+    "regen-docs": "npm run build && tspd doc . --enable-experimental --output-dir ../../website/src/content/docs/docs/emitters/clients/typespec-ts/reference --skip-js"
   }
 }

package/src/context-manager.ts

@@ -0,0 +1,101 @@
+import { SdkContext } from "@azure-tools/typespec-client-generator-core";
+import { EmitContext } from "@typespec/compiler";
+import { Project, SourceFile } from "ts-morph";
+import { ExternalDependencies } from "./framework/dependency.js";
+import { Binder } from "./framework/hooks/binder.js";
+import { SdkTypeContext } from "./framework/hooks/sdk-types.js";
+import { RlcMetaTree } from "./meta-tree.js";
+
+/**
+ * Contexts Object Guidelines
+ * --------------------------
+ * The `Contexts` object contains various application-wide data that needs to be accessible across different parts of the program without the need to pass down props deeply.
+ *
+ * When to add a new context:
+ * - **Cross-Cutting Concerns**: Add a new context when the data or functionality is a cross-cutting concern used by multiple unrelated components or modules.
+ * - **Global State**: If the state needs to be globally accessible and mutable by different parts of the application, and does not belong to a specific component or module.
+ * - **Performance Optimization**: To avoid unnecessary compute or prop drilling that may lead to performance bottlenecks, especially when passing down props through many levels.
+ * - **Shared Resources**: For resources that are shared across various parts of the application, such as settings, configurations, or metadata.
+ *
+ * Remember, adding too many contexts can lead to complex dependencies and harder-to-maintain code. Always evaluate if the context is truly necessary or if there are better alternatives such as localized state management or passing props for simpler scenarios.
+ */
+type Contexts = {
+  rlcMetaTree: RlcMetaTree; // Context for RLC types metadata.
+  outputProject: Project; // The TS-Morph root project context for code generation.
+  symbolMap: Map<string, SourceFile>; // Mapping of symbols to their corresponding source files.
+  sdkTypes: SdkTypeContext;
+  emitContext: {
+    compilerContext: EmitContext;
+    tcgcContext: SdkContext;
+  };
+  binder: Binder;
+  dependencies: ExternalDependencies;
+};
+
+type ContextKey = keyof Contexts;
+
+/**
+ * Manages shared contexts across the application to minimize prop drilling and enhance modularity.
+ * Implements the Singleton pattern to ensure there is a single instance of ContextManager.
+ */
+class ContextManager {
+  private static instance: ContextManager;
+  private contexts: Map<ContextKey, any> = new Map();
+
+  private constructor() {}
+
+  /**
+   * Retrieves the singleton instance of the ContextManager.
+   * @returns {ContextManager} The singleton instance.
+   */
+  public static getInstance(): ContextManager {
+    if (!ContextManager.instance) {
+      ContextManager.instance = new ContextManager();
+    }
+    return ContextManager.instance;
+  }
+
+  /**
+   * Sets a value for a specific context key.
+   * @param {ContextKey} key - The key of the context to set.
+   * @param {Contexts[K]} value - The value to set for the specified context.
+   */
+  public setContext<K extends ContextKey>(key: K, value: Contexts[K]): void {
+    this.contexts.set(key, value);
+  }
+
+  /**
+   * Retrieves the context value for a specific key.
+   * @param {ContextKey} key - The key of the context to retrieve.
+   * @returns {Contexts[K] | undefined} The value of the context if found, otherwise undefined.
+   */
+  public getContext<K extends ContextKey>(key: K): Contexts[K] | undefined {
+    return this.contexts.get(key) as Contexts[K] | undefined;
+  }
+}
+
+// Expose the singleton instance of the context manager.
+export const contextManager = ContextManager.getInstance();
+
+/**
+ * A utility function to use a context by key.
+ * @param {ContextKey} key - The key of the context to retrieve.
+ * @throws Will throw an error if the context is not found.
+ * @returns {Contexts[K]} The context value.
+ */
+export function useContext<K extends ContextKey>(key: K): Contexts[K] {
+  const context = contextManager.getContext(key);
+  if (!context) {
+    throw new Error(`Context ${key} not found`);
+  }
+  return context;
+}
+
+/**
+ * Provides a context with a value to be accessible across the program.
+ * @param {ContextKey} key - The key of the context to provide.
+ * @param {Contexts[K]} value - The value to set for the specified context.
+ */
+export function provideContext<K extends ContextKey>(key: K, value: Contexts[K]): void {
+  contextManager.setContext(key, value);
+}

package/src/framework/hooks/binder.ts

@@ -1,5 +1,4 @@
-import { normalizePath } from "@typespec/compiler";
-import path from "path/posix";
+import { joinPaths, normalizePath } from "@typespec/compiler";
 import {
   ImportDeclarationStructure,
   ImportSpecifierStructure,
@@ -7,12 +6,12 @@ import {
   SourceFile,
   StructureKind,
 } from "ts-morph";
-import { provideContext, useContext } from "../../contextManager.js";
-import { generateLocallyUniqueName } from "../../modular/helpers/namingHelpers.js";
+import { provideContext, useContext } from "../../context-manager.js";
+import { generateLocallyUniqueName } from "../../modular/helpers/naming-helpers.js";
 import { ReferenceableSymbol } from "../dependency.js";
 import { SourceFileSymbol, StaticHelperMetadata } from "../load-static-helpers.js";
 import { refkey } from "../refkey.js";
-import { provideDependencies, useDependencies } from "./useDependencies.js";
+import { provideDependencies, useDependencies } from "./use-dependencies.js";
 
 export interface DeclarationInfo {
   name: string;
@@ -354,7 +353,7 @@ class BinderImp implements Binder {
 
     // Also keep files that are imported by any used helper file
     const helperFiles = this.project.getSourceFiles(
-      normalizePath(path.join(sourceRoot, "static-helpers/**/*.*ts")),
+      normalizePath(joinPaths(sourceRoot, "static-helpers/**/*.*ts")),
     );
     const usedFiles = helperFiles.filter((file) => !isFileUnused(file, usedHelperNames));
     for (const usedFile of usedFiles) {
@@ -378,7 +377,7 @@ class BinderImp implements Binder {
     }
     this.project
       //normalizae the final path to adapt to different systems
-      .getSourceFiles(normalizePath(path.join(testRoot, "test/generated/util/**/*.*ts")))
+      .getSourceFiles(normalizePath(joinPaths(testRoot, "test/generated/util/**/*.*ts")))
       .filter((file) => isFileUnused(file, usedHelperNames))
       .forEach((helperFile) => helperFile.delete());
   }

package/src/framework/hooks/sdk-types.ts

@@ -0,0 +1,218 @@
+import {
+  SdkClientType,
+  SdkHttpOperation,
+  SdkModelPropertyType,
+  SdkModelType,
+  SdkServiceMethod,
+  SdkType,
+  getClientType,
+} from "@azure-tools/typespec-client-generator-core";
+import { Operation, Type, getNamespaceFullName } from "@typespec/compiler";
+import { provideContext, useContext } from "../../context-manager.js";
+
+import { reportDiagnostic } from "../../lib.js";
+import { visitPackageTypes } from "../../modular/emit-models.js";
+import { getAllAncestors, getAllProperties } from "../../modular/helpers/operation-helpers.js";
+import { normalizeModelPropertyName } from "../../modular/type-expressions/get-type-expression.js";
+import { NameType, normalizeName } from "../../rlc-common/index.js";
+import { SdkContext } from "../../utils/interfaces.js";
+
+export const emitQueue: Set<SdkType> = new Set<SdkType>();
+export const flattenPropertyModelMap: Map<SdkModelPropertyType, SdkModelType> = new Map<
+  SdkModelPropertyType,
+  SdkModelType
+>();
+/**
+ * Set of paged result models that are also used in non-paging operations.
+ * Precomputed during visitPackageTypes for O(1) lookups in normalizeModelName.
+ */
+export const pagedModelsUsedInNonPagingOps = new Set<SdkType>();
+
+export interface SdkTypeContext {
+  operations: Map<Type, SdkServiceMethod<SdkHttpOperation>>;
+  types: Map<Type, SdkType>;
+  flattenProperties: Map<SdkModelPropertyType, SdkFlattenPropertyContext>;
+}
+
+export interface SdkFlattenPropertyContext {
+  baseModel: SdkModelType;
+  conflictMap?: Map<SdkModelPropertyType, string>;
+}
+
+export function useSdkTypes() {
+  const sdkTypesContext = useContext("sdkTypes");
+  const { tcgcContext } = useContext("emitContext");
+
+  function getSdkType(type: Operation): SdkServiceMethod<SdkHttpOperation>;
+  function getSdkType(type: Type): SdkType;
+  function getSdkType(type: Type | Operation): SdkType | SdkServiceMethod<SdkHttpOperation> {
+    let sdkType: SdkType | SdkServiceMethod<SdkHttpOperation> | undefined;
+
+    if (type.kind === "Operation") {
+      sdkType = sdkTypesContext.operations.get(type);
+    } else {
+      sdkType = sdkTypesContext.types.get(type) ?? getClientType(tcgcContext, type);
+    }
+
+    if (!sdkType) {
+      throw new Error(
+        `SdkType not found for type: ${type.kind} ${
+          "name" in type && typeof type.name === "string" ? type.name : ""
+        } ${
+          "namespace" in type && type.namespace ? ` in ${getNamespaceFullName(type.namespace)}` : ""
+        }`,
+      );
+    }
+
+    return sdkType;
+  }
+
+  return getSdkType;
+}
+
+export function provideSdkTypes(context: SdkContext) {
+  const { sdkPackage } = context;
+  const sdkTypesContext: SdkTypeContext = {
+    operations: new Map<Type, SdkServiceMethod<SdkHttpOperation>>(),
+    types: new Map<Type, SdkType>(),
+    flattenProperties: new Map<SdkModelPropertyType, SdkFlattenPropertyContext>(),
+  };
+  visitPackageTypes(context);
+  enrichFlattenProperties(context, sdkTypesContext.flattenProperties, flattenPropertyModelMap);
+  for (const sdkModel of emitQueue) {
+    switch (sdkModel.kind) {
+      case "model":
+        sdkModel.properties.forEach((prop) => {
+          sdkTypesContext.types.set(prop.type.__raw!, prop.type);
+        });
+        if (sdkModel.discriminatedSubtypes) {
+          Object.values(sdkModel.discriminatedSubtypes).forEach((subtype) => {
+            sdkTypesContext.types.set(subtype.__raw!, subtype);
+          });
+        }
+        break;
+      case "enum":
+        if (sdkModel.__raw) {
+          sdkTypesContext.types.set(sdkModel.__raw, sdkModel);
+        }
+        break;
+      case "union":
+        sdkModel.variantTypes.forEach((v) => {
+          if (v.__raw) {
+            sdkTypesContext.types.set(v.__raw, v);
+          }
+        });
+        break;
+      case "array":
+        sdkTypesContext.types.set(sdkModel.valueType.__raw!, sdkModel.valueType);
+        break;
+      case "dict":
+        sdkTypesContext.types.set(sdkModel.valueType.__raw!, sdkModel.valueType);
+        break;
+      case "nullable":
+        sdkTypesContext.types.set(sdkModel.__raw!, sdkModel);
+        sdkTypesContext.types.set(sdkModel.type.__raw!, sdkModel.type);
+        break;
+    }
+    if (!sdkModel.__raw) {
+      continue;
+    }
+    sdkTypesContext.types.set(sdkModel.__raw, sdkModel);
+  }
+
+  for (const client of sdkPackage.clients) {
+    for (const method of getAllOperationsFromClient(client)) {
+      if (!method.__raw) {
+        continue;
+      }
+
+      sdkTypesContext.operations.set(method.__raw, method);
+
+      // Visit the parameters of the method to add them to the types map
+      method.parameters.forEach((param) => {
+        sdkTypesContext.types.set(param.type.__raw!, param.type);
+      });
+    }
+  }
+
+  provideContext("sdkTypes", sdkTypesContext);
+}
+
+// Enrich flatten properties with their base models and conflict maps
+function enrichFlattenProperties(
+  context: SdkContext,
+  propertyContextMap: Map<SdkModelPropertyType, SdkFlattenPropertyContext>,
+  propertyModelMap: Map<SdkModelPropertyType, SdkModelType>,
+) {
+  // Build a map of base model to its existing properties excluding flatten properties
+  // To check for conflicts later
+  const baseModelProperties = new Map<SdkModelType, Set<string>>();
+  propertyModelMap.forEach((baseModel, _) => {
+    if (!baseModelProperties.has(baseModel)) {
+      const propertiesExcludedFlatten = getAllProperties(
+        context,
+        baseModel,
+        getAllAncestors(baseModel),
+      )
+        .filter((p) => !(p.flatten && p.type.kind === "model"))
+        .map((p) => normalizeModelPropertyName(context, p));
+      baseModelProperties.set(baseModel, new Set<string>(propertiesExcludedFlatten));
+    }
+  });
+  for (const [flattenProperty, baseModel] of propertyModelMap) {
+    const flattenContext: SdkFlattenPropertyContext = {
+      baseModel: baseModel,
+    };
+    propertyContextMap.set(flattenProperty, flattenContext);
+    const existingProperties = baseModelProperties.get(baseModel)!;
+    const conflictMap = new Map<SdkModelPropertyType, string>();
+    const flattenModel = flattenProperty.type;
+
+    if (baseModelProperties.has(flattenModel as SdkModelType)) {
+      // If the flatten model is also a base model of other flatten properties, which means it has multiple consecutive flatten operations
+      // Since we cannot handle the flatten transition, report warning and skip it for now
+      reportDiagnostic(context.program, {
+        code: "unsupported-flatten-transition",
+        format: {
+          propertyName: flattenProperty.name,
+          modelName: baseModel.name,
+        },
+        target: flattenProperty.__raw!,
+      });
+    }
+    const allFlattenProperties = getAllProperties(
+      context,
+      flattenModel,
+      getAllAncestors(flattenModel),
+    );
+    for (const flattenChildProperty of allFlattenProperties) {
+      let childPropertyName = normalizeModelPropertyName(context, flattenChildProperty);
+      if (existingProperties.has(childPropertyName)) {
+        childPropertyName = normalizeName(
+          `${childPropertyName}_${flattenProperty.name}_${childPropertyName}`,
+          NameType.Property,
+        );
+        conflictMap.set(flattenChildProperty, childPropertyName);
+      }
+      existingProperties.add(childPropertyName);
+    }
+    if (conflictMap.size === 0) {
+      continue;
+    }
+    flattenContext.conflictMap = conflictMap;
+  }
+}
+
+export function getAllOperationsFromClient(client: SdkClientType<SdkHttpOperation>) {
+  const clientQueue = [client];
+  const operations: SdkServiceMethod<SdkHttpOperation>[] = [];
+  while (clientQueue.length > 0) {
+    const client = clientQueue.pop()!;
+    if (client.children) {
+      clientQueue.push(...client.children);
+    }
+    operations.push(...client.methods);
+  }
+
+  return operations;
+}

package/src/framework/hooks/use-dependencies.ts

@@ -0,0 +1,16 @@
+import { provideContext, useContext } from "../../context-manager.js";
+import { DefaultCoreDependencies } from "../../modular/external-dependencies.js";
+import { ExternalDependencies } from "../dependency.js";
+
+export function provideDependencies(customDependencies: Partial<ExternalDependencies> = {}) {
+  const dependencies = {
+    ...DefaultCoreDependencies,
+    ...customDependencies,
+  } as ExternalDependencies;
+
+  provideContext("dependencies", dependencies);
+}
+
+export function useDependencies(): ExternalDependencies {
+  return useContext("dependencies");
+}

package/src/framework/load-static-helpers.ts

@@ -1,6 +1,5 @@
-import { NoTarget, Program } from "@typespec/compiler";
+import { joinPaths, NoTarget, Program } from "@typespec/compiler";
 import { readdir, readFile, stat } from "fs/promises";
-import * as path from "path";
 import {
   ClassDeclaration,
   EnumDeclaration,
@@ -55,7 +54,7 @@ export async function loadStaticHelpers(
 ): Promise<Map<string, StaticHelperMetadata>> {
   const helpersMap = new Map<string, StaticHelperMetadata>();
   // Load static helpers used in sources code
-  const defaultStaticHelpersPath = path.join(
+  const defaultStaticHelpersPath = joinPaths(
     resolveProjectRoot(),
     DEFAULT_SOURCES_STATIC_HELPERS_PATH,
   );
@@ -69,7 +68,7 @@ export async function loadStaticHelpers(
     options.loadTestHelpers ??
     (options.options?.generateTest && isAzurePackage({ options: options.options }))
   ) {
-    const defaultTestingHelpersPath = path.join(
+    const defaultTestingHelpersPath = joinPaths(
       resolveProjectRoot(),
       DEFAULT_SOURCES_TESTING_HELPERS_PATH,
     );
@@ -86,7 +85,7 @@ export async function loadStaticHelpers(
 
   async function loadFiles(files: FileMetadata[], generateDir: string) {
     for (const file of files) {
-      const targetPath = path.join(generateDir, file.target);
+      const targetPath = joinPaths(generateDir, file.target);
       const contents = await readFile(file.source, "utf-8");
       const addedFile = project.createSourceFile(targetPath, contents, {
         overwrite: true,
@@ -200,7 +199,7 @@ async function traverseDirectory(
 
     await Promise.all(
       files.map(async (file) => {
-        const filePath = path.join(directory, file);
+        const filePath = joinPaths(directory, file);
         const fileStat = await stat(filePath);
 
         if (fileStat.isDirectory()) {
@@ -208,11 +207,11 @@ async function traverseDirectory(
             filePath,
             program,
             result,
-            path.join(relativePath, file),
+            joinPaths(relativePath, file),
             targetBaseDir,
           );
         } else if (fileStat.isFile() && !file.endsWith(".d.ts") && /.*\..?ts$/.test(file)) {
-          const target = path.join(targetBaseDir, relativePath, file);
+          const target = joinPaths(targetBaseDir, relativePath, file);
           result.push({ source: filePath, target });
         }
       }),