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

package/src/utils/emitUtil.ts

@@ -1,92 +0,0 @@
-import { CompilerHost, NoTarget, Program } from "@typespec/compiler";
-import { dirname, join } from "path";
-import { format } from "prettier";
-import { prettierJSONOptions, prettierTypeScriptOptions, reportDiagnostic } from "../lib.js";
-import {
-  buildSchemaTypes,
-  ContentBuilder,
-  File,
-  isAzurePackage,
-  RLCModel,
-} from "../rlc-common/index.js";
-
-export async function emitModels(rlcModels: RLCModel, program: Program) {
-  const schemaOutput = buildSchemaTypes(rlcModels);
-  const isAzureFlavor = isAzurePackage(rlcModels);
-  if (schemaOutput) {
-    const { inputModelFile, outputModelFile } = schemaOutput;
-    if (inputModelFile) {
-      await emitFile(inputModelFile, program, isAzureFlavor);
-    }
-    if (outputModelFile) {
-      await emitFile(outputModelFile, program, isAzureFlavor);
-    }
-  }
-}
-
-export async function emitContentByBuilder(
-  program: Program,
-  builderFnOrList: ContentBuilder | ContentBuilder[],
-  rlcModels: RLCModel,
-  emitterOutputDir?: string,
-) {
-  if (!Array.isArray(builderFnOrList)) {
-    builderFnOrList = [builderFnOrList];
-  }
-  const isAzureFlavor = isAzurePackage(rlcModels);
-  for (const builderFn of builderFnOrList) {
-    let contentFiles: File[] | File | undefined = builderFn(rlcModels);
-    if (!contentFiles) {
-      continue;
-    }
-    if (!Array.isArray(contentFiles)) {
-      contentFiles = [contentFiles];
-    }
-    for (const file of contentFiles) {
-      await emitFile(file, program, isAzureFlavor, emitterOutputDir);
-    }
-  }
-}
-
-async function emitFile(
-  file: File,
-  program: Program,
-  isAzureFlavor: boolean,
-  emitterOutputDir?: string,
-) {
-  if (program.compilerOptions.noEmit || program.hasError()) {
-    return;
-  }
-  const host: CompilerHost = program.host;
-  const filePath = join(emitterOutputDir ?? "", file.path);
-  const isJson = /\.json$/gi.test(filePath);
-  const isSourceCode = /\.(ts|js)$/gi.test(filePath);
-  const microsoftHeader = isAzureFlavor ? `// Copyright (c) Microsoft Corporation.\n` : "";
-  const licenseHeader = `${microsoftHeader}// Licensed under the MIT License.\n`;
-  let prettierFileContent = file.content;
-
-  if (isSourceCode) {
-    prettierFileContent = `${licenseHeader.trimStart()}\n${prettierFileContent}`;
-  }
-  // Format the contents if necessary
-  if (isJson || isSourceCode) {
-    try {
-      prettierFileContent = await format(
-        prettierFileContent,
-        isJson ? prettierJSONOptions : prettierTypeScriptOptions,
-      );
-    } catch (e) {
-      reportDiagnostic(program, {
-        code: "file-formatting-error",
-        format: {
-          filePath: filePath,
-          error: String(e),
-        },
-        target: NoTarget,
-      });
-      // Continue with unformatted content rather than crashing
-    }
-  }
-  await host.mkdirp(dirname(filePath));
-  await host.writeFile(filePath, prettierFileContent);
-}

package/src/utils/fileSystemUtils.ts

@@ -1,69 +0,0 @@
-import { NoTarget, Program } from "@typespec/compiler";
-import { mkdir, readdir, rm, stat } from "fs/promises";
-import { resolve } from "path";
-import { reportDiagnostic } from "../lib.js";
-
-export async function pathExists(targetPath: string): Promise<boolean> {
-  try {
-    await stat(targetPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function emptyDir(dirPath: string): Promise<void> {
-  let entries: string[];
-  try {
-    entries = await readdir(dirPath);
-  } catch {
-    await mkdir(dirPath, { recursive: true });
-    return;
-  }
-
-  await Promise.all(
-    entries.map((entry) => rm(resolve(dirPath, entry), { recursive: true, force: true })),
-  );
-}
-
-export async function clearDirectory(
-  dirPath: string,
-  excludeNames: string[] = [],
-  program?: Program,
-): Promise<void> {
-  if (!(await pathExists(dirPath))) {
-    return;
-  }
-
-  // If no exclude names, just use regular emptyDir for efficiency
-  if (excludeNames.length === 0) {
-    await emptyDir(dirPath);
-    return;
-  }
-
-  try {
-    // Get all subdirectories and files
-    const entries = await readdir(dirPath);
-
-    // Filter entries to exclude those that should be preserved
-    const filteredEntries = entries.filter((entry) => {
-      return !excludeNames.includes(entry);
-    });
-
-    // Process each entry
-    for (const entry of filteredEntries) {
-      const entryPath = resolve(dirPath, entry);
-      await rm(entryPath, { recursive: true, force: true });
-    }
-  } catch (error) {
-    // If there's an error, fall back to regular emptyDir
-    if (program) {
-      reportDiagnostic(program, {
-        code: "directory-traversal-error",
-        format: { directory: dirPath, error: String(error) },
-        target: NoTarget,
-      });
-    }
-    await emptyDir(dirPath);
-  }
-}

package/src/utils/importHelper.ts

@@ -1,59 +0,0 @@
-import { dirname, relative, resolve } from "path";
-import { SourceFile } from "ts-morph";
-import { useContext } from "../contextManager.js";
-
-/**
- * Adds a named import to a TypeScript source file if it does not already exist.
- * Utilizes a global symbol map context to resolve module paths and ensure the import is correctly referenced.
- *
- * @param {string} symbol The name of the export to import.
- * @param {SourceFile} currentFile The ts-morph SourceFile object where the import will be added.
- */
-export function addImportBySymbol(symbol: string, currentFile: SourceFile) {
-  // Retrieve the global map of symbols to their source files.
-  const symbolMap = useContext("symbolMap");
-
-  // Attempt to resolve the file path for the given symbol.
-  const modulePath = symbolMap.get(symbol)?.getFilePath();
-  if (!modulePath) {
-    return;
-  }
-
-  // Resolve absolute path and compute a relative path from the current file to the module.
-  const moduleAbsolutePath = resolve(modulePath);
-  const relativeImportPath = getRelativeImportPath(currentFile.getFilePath(), moduleAbsolutePath)
-    .replace(/\\/g, "/")
-    .replace(/\.ts$/, ".js");
-
-  // Check if the import declaration already exists and if it includes the symbol.
-  const existing = currentFile.getImportDeclaration(
-    (i) => i.getModuleSpecifierValue() === relativeImportPath,
-  );
-
-  if (existing) {
-    const sameImport = existing.getNamedImports().some((i) => i.getName() === symbol);
-
-    if (!sameImport) {
-      existing.addNamedImport(symbol);
-    }
-  } else {
-    currentFile.addImportDeclaration({
-      moduleSpecifier: relativeImportPath,
-      namedImports: [symbol],
-    });
-  }
-}
-
-/**
- * Computes a relative import path suitable for TypeScript imports given two file paths.
- * Ensures the returned path starts with './' if necessary to be recognized as a relative module.
- *
- * @param {string} from The file path to import from.
- * @param {string} to The file path to import to.
- * @returns {string} The relative path adjusted for import syntax.
- */
-function getRelativeImportPath(from: string, to: string) {
-  const relativePath = relative(dirname(from), to);
-  // Adjust the path format to TypeScript module syntax
-  return relativePath.startsWith(".") ? relativePath : "./" + relativePath;
-}