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

package/src/rlc-common/metadata/build-readme-file.ts

@@ -3,11 +3,9 @@
 
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore: to fix the handlebars issue
-import { readFileSync } from "fs";
 import hbs from "handlebars";
 import { getClientName } from "../helpers/name-constructors.js";
 import { NameType, normalizeName } from "../helpers/name-utils.js";
-import { isAzurePackage } from "../helpers/package-util.js";
 import { RLCModel } from "../interfaces.js";
 
 const azureReadmeRLCTemplate = `# {{ clientDescriptiveName }} library for JavaScript
@@ -350,7 +348,7 @@ interface Metadata {
 export function buildReadmeFile(model: RLCModel) {
   const metadata = createMetadata(model) ?? {};
   const readmeFileContents = hbs.compile(
-    model.options && isAzurePackage(model)
+    model.options
       ? model.options.isModularLibrary
         ? azureReadmeModularTemplate
         : azureReadmeRLCTemplate
@@ -363,10 +361,9 @@ export function buildReadmeFile(model: RLCModel) {
   };
 }
 
-export function hasClientNameChanged(model: RLCModel, existingReadmeFilePath: string): boolean {
+export function hasClientNameChanged(model: RLCModel, existingReadmeContent: string): boolean {
   try {
-    const existingContent = readFileSync(existingReadmeFilePath, "utf8");
-    const importMatch = existingContent.match(
+    const importMatch = existingReadmeContent.match(
       /import\s*\{\s*([A-Za-z0-9_]+)\s*\}\s*from\s*["'][^"']*["']/,
     );
     const existingClientName = importMatch?.[1];
@@ -379,21 +376,20 @@ export function hasClientNameChanged(model: RLCModel, existingReadmeFilePath: st
 
 export function updateReadmeFile(
   model: RLCModel,
-  existingReadmeFilePath: string,
+  existingReadmeContent: string,
 ): { path: string; content: string } | undefined {
   try {
-    const existingContent = readFileSync(existingReadmeFilePath, "utf8");
     const metadata = createMetadata(model) ?? {};
 
     const newApiRefLink = hbs.compile(apiReferenceTemplate, { noEscape: true })(metadata).trim();
 
     if (!newApiRefLink) {
-      return { path: "README.md", content: existingContent };
+      return { path: "README.md", content: existingReadmeContent };
     }
 
     const apiRefRegex =
       /^- \[API reference documentation\]\(https:\/\/learn\.microsoft\.com\/javascript\/api\/[^)]+\)$/m;
-    const updatedContent = existingContent.replace(apiRefRegex, (match) =>
+    const updatedContent = existingReadmeContent.replace(apiRefRegex, (match) =>
       match ? newApiRefLink : match,
     );
 

package/src/rlc-common/metadata/build-rollup-config.ts

@@ -2,17 +2,16 @@
 // Licensed under the MIT License.
 
 import { Project } from "ts-morph";
-import { isAzurePackage } from "../helpers/package-util.js";
 import { RLCModel } from "../interfaces.js";
 
 export function buildRollupConfig(model: RLCModel) {
   const azureSdkForJs = Boolean(model.options?.azureSdkForJs);
   // Only generate the file when it is not in sdk repo
-  if (isAzurePackage(model) && (azureSdkForJs === true || azureSdkForJs === undefined)) {
+  if (azureSdkForJs === true || azureSdkForJs === undefined) {
     return;
   }
 
-  const project = new Project();
+  const project = new Project({ useInMemoryFileSystem: true });
   const filePath = "rollup.config.js";
   const rollupFile = project.createSourceFile(filePath, undefined, {
     overwrite: true,

package/src/rlc-common/metadata/build-sample-env-file.ts

@@ -7,10 +7,7 @@ const sampleEnvText = `
 `;
 
 export function buildSampleEnvFile(model: RLCModel) {
-  if (
-    (model.options?.generateMetadata === true || model.options?.generateSample === true) &&
-    model.options?.flavor === "azure"
-  ) {
+  if (model.options?.generateMetadata === true || model.options?.generateSample === true) {
     const filePath = "sample.env";
     return {
       path: filePath,

package/src/rlc-common/metadata/build-ts-config.ts

@@ -14,7 +14,7 @@ export function buildTsConfig(model: RLCModel) {
   const { packageDetails, azureSdkForJs } = model.options || {};
   const { generateTest, generateSample, generateReactNativeTarget } = model.options || {};
   const clientPackageName = packageDetails?.name ?? "";
-  const project = new Project();
+  const project = new Project({ useInMemoryFileSystem: true });
 
   let tsConfig: Record<string, any>;
 

package/src/rlc-common/metadata/package-json/package-common.ts

@@ -40,10 +40,6 @@ export function getPackageCommonInfo(config: PackageCommonInfoConfig) {
   };
 }
 
-export const commonPackageDependencies = {
-  tslib: "^2.6.2",
-};
-
 export function getCommonPackageDevDependencies(config: PackageCommonInfoConfig) {
   return {
     "@types/node": "^20.0.0",

package/src/rlc-common/transform-sample-groups.ts

@@ -1,6 +1,5 @@
 import { getClientName } from "./helpers/name-constructors.js";
 import { NameType, camelCase, normalizeName } from "./helpers/name-utils.js";
-import { isAzurePackage } from "./helpers/package-util.js";
 import { buildSchemaObjectMap } from "./helpers/schema-helpers.js";
 import { generateParameterTypeValue } from "./helpers/value-generation-util.js";
 import {
@@ -201,13 +200,8 @@ function convertClientLevelParameters(
     // Do not include parameters with constant values in the signature, these should go in the options bag
     (p) => p.value === undefined,
   );
-  const {
-    addCredentials,
-    credentialScopes,
-    credentialKeyHeaderName,
-    customHttpAuthHeaderName,
-    flavor,
-  } = model.options;
+  const { addCredentials, credentialScopes, credentialKeyHeaderName, customHttpAuthHeaderName } =
+    model.options;
   const hasUrlParameter = !!urlParameters,
     hasCredentials =
       addCredentials && (credentialScopes || credentialKeyHeaderName || customHttpAuthHeaderName);
@@ -227,34 +221,25 @@ function convertClientLevelParameters(
   }
   if (hasCredentials) {
     // Currently only support token credential
-    const apiKeyCredentialPackage = isAzurePackage(model)
-      ? "@azure/core-auth"
-      : "@typespec/ts-http-runtime";
-    const tokenCredentialPackage = isAzurePackage(model)
-      ? "@azure/identity"
-      : "@typespec/ts-http-runtime";
-    if (credentialKeyHeaderName && isAzurePackage(model)) {
+    const apiKeyCredentialPackage = "@azure/core-auth";
+    const tokenCredentialPackage = "@azure/identity";
+    if (credentialKeyHeaderName) {
       clientParams.push({
         name: "credential",
         assignment: `const credential = new AzureKeyCredential("{Your API key}");`,
       });
       addValueInImportedDict(apiKeyCredentialPackage, "AzureKeyCredential", importedDict);
-    } else if ((credentialKeyHeaderName && flavor !== "azure") || customHttpAuthHeaderName) {
+    } else if (customHttpAuthHeaderName) {
       clientParams.push({
         name: "credential",
         assignment: `const credential = { key: "{Your API key}"};`,
       });
-    } else if (isAzurePackage(model)) {
+    } else {
       clientParams.push({
         name: "credential",
         assignment: "const credential = new DefaultAzureCredential();",
       });
       addValueInImportedDict(tokenCredentialPackage, "DefaultAzureCredential", importedDict);
-    } else {
-      clientParams.push({
-        name: "credential",
-        assignment: `const credential = {getToken: () => Promise.resolve({ token: "{Your token}", expiresOnTimestamp: 0 })};`,
-      });
     }
   }
   return clientParams;

package/src/transform/transform-helper-function-details.ts

@@ -1,5 +1,5 @@
 import { getHttpOperationWithCache, SdkClient } from "@azure-tools/typespec-client-generator-core";
-import { HelperFunctionDetails, PackageFlavor } from "../rlc-common/index.js";
+import { HelperFunctionDetails } from "../rlc-common/index.js";
 import { listOperationsUnderRLCClient } from "../utils/client-utils.js";
 import { SdkContext } from "../utils/interfaces.js";
 import { getCollectionFormat } from "../utils/model-utils.js";
@@ -13,17 +13,8 @@ import {
 export function transformHelperFunctionDetails(
   client: SdkClient,
   dpgContext: SdkContext,
-  flavor?: PackageFlavor,
 ): HelperFunctionDetails {
   const serializeInfo = extractSpecialSerializeInfo(client, dpgContext);
-  // Disable paging and long running for non-Azure clients.
-  if (flavor !== "azure") {
-    return {
-      hasLongRunning: false,
-      hasPaging: false,
-      ...serializeInfo,
-    };
-  }
 
   const annotationDetails = {
     hasLongRunning: hasPollingOperations(client, dpgContext),

package/src/transform/transform.ts

@@ -72,7 +72,7 @@ export async function transformRLCModel(
     importSet,
     urlInfo?.apiVersionInfo,
   );
-  const helperDetails = transformHelperFunctionDetails(client, dpgContext, options.flavor);
+  const helperDetails = transformHelperFunctionDetails(client, dpgContext);
   // Enrich client-level annotation detail
   helperDetails.clientLroOverload = getClientLroOverload(paths);
 
@@ -91,7 +91,7 @@ export async function transformRLCModel(
     telemetryOptions,
     importInfo: {
       internalImports: importSet,
-      runtimeImports: buildRuntimeImports(options.flavor),
+      runtimeImports: buildRuntimeImports(),
     },
     rlcSourceDir,
   };

package/src/transform/transfrom-rlc-options.ts

@@ -7,7 +7,6 @@ import {
   NameType,
   normalizeName,
   PackageDetails,
-  PackageFlavor,
   pascalCase,
   RLCOptions,
   ServiceInfo,
@@ -43,13 +42,12 @@ function extractRLCOptions(
   const isModularLibrary = emitterOptions["is-modular-library"] !== false;
   const includeShortcuts = getIncludeShortcuts(emitterOptions);
   const packageDetails = getPackageDetails(program, emitterOptions, isModularLibrary);
-  const flavor = getFlavor(emitterOptions, packageDetails);
   const moduleKind = getModuleKind(emitterOptions);
   const serviceInfo = getServiceInfo(program, isModularLibrary);
   const includeHeadersInResponse = emitterOptions["include-headers-in-response"] === true;
-  const azureSdkForJs = getAzureSdkForJs(emitterOptions, flavor);
+  const azureSdkForJs = getAzureSdkForJs(emitterOptions);
   const generateMetadata = getGenerateMetadata(emitterOptions);
-  const generateTest = getGenerateTest(emitterOptions, flavor);
+  const generateTest = getGenerateTest(emitterOptions);
   const generateSample = getGenerateSample(dpgContext, emitterOptions);
   const credentialInfo = getCredentialInfo(program, emitterOptions, isModularLibrary);
   const azureOutputDirectory = getAzureOutputDirectory(generationRootDir);
@@ -77,14 +75,13 @@ function extractRLCOptions(
   const typespecTitleMap = emitterOptions["typespec-title-map"];
   const generateReactNativeTarget = emitterOptions["generate-react-native-target"] === true;
   const hasSubscriptionId = getSubscriptionId(dpgContext);
-  const ignoreNullableOnOptional = getIgnoreNullableOnOptional(emitterOptions, flavor);
-  const wrapNonModelReturn = getWrapNonModelReturn(emitterOptions, flavor);
+  const ignoreNullableOnOptional = getIgnoreNullableOnOptional(emitterOptions);
+  const wrapNonModelReturn = getWrapNonModelReturn(emitterOptions);
   const isMultiService = (dpgContext.allServiceNamespaces?.length ?? 0) > 1;
 
   return {
     ...credentialInfo,
     includeHeadersInResponse,
-    flavor,
     moduleKind,
     includeShortcuts,
     packageDetails,
@@ -247,25 +244,22 @@ function detectIfNameConflicts(dpgContext: SdkContext, isModularLibrary: boolean
   return false;
 }
 
-function getIgnoreNullableOnOptional(
-  emitterOptions: EmitterOptions,
-  flavor: PackageFlavor,
-): boolean {
+function getIgnoreNullableOnOptional(emitterOptions: EmitterOptions): boolean {
   // If explicitly set in options, use that value
   if (emitterOptions["ignore-nullable-on-optional"] !== undefined) {
     return Boolean(emitterOptions["ignore-nullable-on-optional"]);
   }
-  // Default to true for Azure services (same as HLC behavior)
-  return flavor === "azure";
+  // Default to true (same as HLC behavior)
+  return true;
 }
 
-function getWrapNonModelReturn(emitterOptions: EmitterOptions, flavor: PackageFlavor): boolean {
+function getWrapNonModelReturn(emitterOptions: EmitterOptions): boolean {
   // If explicitly set in options, use that value
   if (emitterOptions["wrap-non-model-return"] !== undefined) {
     return Boolean(emitterOptions["wrap-non-model-return"]);
   }
-  // Default to true for Azure services to maintain HLC backward compatibility
-  return flavor === "azure";
+  // Default to true to maintain HLC backward compatibility
+  return true;
 }
 
 function getIncludeShortcuts(emitterOptions: EmitterOptions) {
@@ -276,32 +270,6 @@ function getModuleKind(emitterOptions: EmitterOptions) {
   return emitterOptions["module-kind"] ?? "esm";
 }
 
-function getFlavor(emitterOptions: EmitterOptions, packageDetails?: PackageDetails): PackageFlavor {
-  const flavor = emitterOptions.flavor;
-
-  if (flavor !== undefined) {
-    if (flavor.toLowerCase() === "azure") {
-      return "azure";
-    } else {
-      return undefined;
-    }
-  }
-
-  const branded = emitterOptions.branded;
-  if (branded !== undefined) {
-    return branded ? "azure" : undefined;
-  }
-
-  const scopeName = packageDetails?.scopeName;
-  if (
-    scopeName !== undefined &&
-    (scopeName.startsWith("azure") || scopeName.startsWith("msinternal"))
-  ) {
-    return "azure";
-  } else {
-    return undefined;
-  }
-}
 function buildPackageDetails(
   program: Program,
   emitterOptions: EmitterOptions,
@@ -350,13 +318,11 @@ function getServiceInfo(program: Program, isModularLibrary: boolean): ServiceInf
   };
 }
 
-function getAzureSdkForJs(emitterOptions: EmitterOptions, flavor: PackageFlavor) {
-  return flavor !== "azure"
-    ? false
-    : emitterOptions["azure-sdk-for-js"] === undefined ||
-        emitterOptions["azure-sdk-for-js"] === null
-      ? true
-      : Boolean(emitterOptions["azure-sdk-for-js"]);
+function getAzureSdkForJs(emitterOptions: EmitterOptions) {
+  return emitterOptions["azure-sdk-for-js"] === undefined ||
+    emitterOptions["azure-sdk-for-js"] === null
+    ? true
+    : Boolean(emitterOptions["azure-sdk-for-js"]);
 }
 
 function getGenerateMetadata(emitterOptions: EmitterOptions) {
@@ -374,9 +340,9 @@ function getGenerateMetadata(emitterOptions: EmitterOptions) {
  * @param emitterOptions
  * @returns
  */
-function getGenerateTest(emitterOptions: EmitterOptions, flavor: PackageFlavor) {
+function getGenerateTest(emitterOptions: EmitterOptions) {
   // Disable generateTest if azureSdkForJS is false
-  if (!getAzureSdkForJs(emitterOptions, flavor)) {
+  if (!getAzureSdkForJs(emitterOptions)) {
     return false;
   }
   return emitterOptions["generate-test"];

package/src/utils/emit-util.ts

@@ -1,24 +1,20 @@
 import { CompilerHost, getDirectoryPath, joinPaths, NoTarget, Program } from "@typespec/compiler";
 import { format } from "prettier";
+import prettierPluginBabel from "prettier/plugins/babel";
+import prettierPluginEstree from "prettier/plugins/estree";
+import prettierPluginTypescript from "prettier/plugins/typescript";
 import { prettierJSONOptions, prettierTypeScriptOptions, reportDiagnostic } from "../lib.js";
-import {
-  buildSchemaTypes,
-  ContentBuilder,
-  File,
-  isAzurePackage,
-  RLCModel,
-} from "../rlc-common/index.js";
+import { buildSchemaTypes, ContentBuilder, File, 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);
+      await emitFile(inputModelFile, program);
     }
     if (outputModelFile) {
-      await emitFile(outputModelFile, program, isAzureFlavor);
+      await emitFile(outputModelFile, program);
     }
   }
 }
@@ -32,7 +28,6 @@ export async function emitContentByBuilder(
   if (!Array.isArray(builderFnOrList)) {
     builderFnOrList = [builderFnOrList];
   }
-  const isAzureFlavor = isAzurePackage(rlcModels);
   for (const builderFn of builderFnOrList) {
     let contentFiles: File[] | File | undefined = builderFn(rlcModels);
     if (!contentFiles) {
@@ -42,17 +37,12 @@ export async function emitContentByBuilder(
       contentFiles = [contentFiles];
     }
     for (const file of contentFiles) {
-      await emitFile(file, program, isAzureFlavor, emitterOutputDir);
+      await emitFile(file, program, emitterOutputDir);
     }
   }
 }
 
-async function emitFile(
-  file: File,
-  program: Program,
-  isAzureFlavor: boolean,
-  emitterOutputDir?: string,
-) {
+async function emitFile(file: File, program: Program, emitterOutputDir?: string) {
   if (program.compilerOptions.noEmit || program.hasError()) {
     return;
   }
@@ -60,8 +50,7 @@ async function emitFile(
   const filePath = joinPaths(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`;
+  const licenseHeader = `// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n`;
   let prettierFileContent = file.content;
 
   if (isSourceCode) {
@@ -70,10 +59,10 @@ async function emitFile(
   // Format the contents if necessary
   if (isJson || isSourceCode) {
     try {
-      prettierFileContent = await format(
-        prettierFileContent,
-        isJson ? prettierJSONOptions : prettierTypeScriptOptions,
-      );
+      prettierFileContent = await format(prettierFileContent, {
+        ...(isJson ? prettierJSONOptions : prettierTypeScriptOptions),
+        plugins: [prettierPluginTypescript, prettierPluginEstree, prettierPluginBabel],
+      });
     } catch (e) {
       reportDiagnostic(program, {
         code: "file-formatting-error",

package/src/utils/file-system-utils.ts

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

package/src/utils/resolve-project-root.ts

@@ -1,26 +1,15 @@
-import { existsSync } from "fs";
-import { dirname, resolve } from "path";
-import { fileURLToPath } from "url";
+import { resolvePath } from "@typespec/compiler";
 
 /**
- * Recursively finds the nearest package.json file starting from the specified directory.
- * @param {string} currentDir - The directory to start searching from. Defaults to the directory of the current module.
- * @returns {string} path to the directory containing the package.json file.
+ * Returns the package root directory for the emitter.
+ *
+ * The compiled output lives at `dist/src/utils/resolve-project-root.js`,
+ * so the package root is 3 levels up. This avoids filesystem access,
+ * making it compatible with virtual file systems (e.g., the playground).
  */
-export function resolveProjectRoot(
-  currentDir: string = dirname(fileURLToPath(import.meta.url)),
-): string {
-  const packageJsonPath = resolve(currentDir, "package.json");
-
-  if (existsSync(packageJsonPath)) {
-    return currentDir;
-  }
-
-  const parentDir = resolve(currentDir, "..");
-
-  if (parentDir === currentDir) {
-    throw new Error("Could not find package.json");
-  }
-
-  return resolveProjectRoot(parentDir);
+export function resolveProjectRoot(): string {
+  // Use the global URL constructor (works in both Node.js and browsers)
+  const currentDir = new URL(".", import.meta.url).pathname;
+  // From dist/src/utils/ -> package root (3 levels: utils -> src -> dist -> root)
+  return resolvePath(currentDir, "../../..");
 }

package/dist/src/rlc-common/metadata/package-json/build-flavorless-package.d.ts

@@ -1,57 +0,0 @@
-import { PackageCommonInfoConfig } from "./package-common.js";
-/**
- * Builds the package.json for a flavorless package.
- */
-export declare function buildFlavorlessPackage(config: PackageCommonInfoConfig): {
-    scripts: {
-        build?: undefined;
-        clean: string;
-        "extract-api": string;
-        pack: string;
-        lint: string;
-        "lint:fix": string;
-    } | {
-        build: string;
-        clean: string;
-        "extract-api": string;
-        pack: string;
-        lint: string;
-        "lint:fix": string;
-    } | {
-        build: string;
-        clean: string;
-        "extract-api": string;
-        pack: string;
-        lint: string;
-        "lint:fix": string;
-    } | {
-        build: string;
-        clean: string;
-        "extract-api": string;
-        pack: string;
-        lint: string;
-        "lint:fix": string;
-    };
-    devDependencies: {
-        "@microsoft/api-extractor": string;
-        rimraf: string;
-        mkdirp: string;
-        tshy?: undefined;
-        "@types/node": string;
-        eslint: string;
-        typescript: string;
-    } | {
-        "@microsoft/api-extractor": string;
-        rimraf: string;
-        mkdirp: string;
-        tshy: string;
-        "@types/node": string;
-        eslint: string;
-        typescript: string;
-    };
-    dependencies: {
-        "@typespec/ts-http-runtime": string;
-        tslib: string;
-    };
-};
-//# sourceMappingURL=build-flavorless-package.d.ts.map

package/dist/src/rlc-common/metadata/package-json/build-flavorless-package.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build-flavorless-package.d.ts","sourceRoot":"","sources":["../../../../../src/rlc-common/metadata/package-json/build-flavorless-package.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,uBAAuB,EAKxB,MAAM,qBAAqB,CAAC;AAE7B;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBrE"}

package/dist/src/rlc-common/metadata/package-json/build-flavorless-package.js

@@ -1,53 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import { commonPackageDependencies, getCommonPackageDevDependencies, getCommonPackageScripts, getPackageCommonInfo, } from "./package-common.js";
-/**
- * Builds the package.json for a flavorless package.
- */
-export function buildFlavorlessPackage(config) {
-    const packageInfo = {
-        ...getFlavorlessPackageInfo(config),
-        scripts: getFlavorlessScripts(config),
-        devDependencies: {
-            ...getCommonPackageDevDependencies(config),
-            "@microsoft/api-extractor": "^7.40.3",
-            rimraf: "^5.0.5",
-            mkdirp: "^3.0.1",
-        },
-        dependencies: {
-            ...commonPackageDependencies,
-            "@typespec/ts-http-runtime": "0.1.0",
-        },
-    };
-    return packageInfo;
-}
-function getFlavorlessPackageInfo(config) {
-    const commonPackageInfo = getPackageCommonInfo(config);
-    return {
-        ...commonPackageInfo,
-    };
-}
-function getFlavorlessScripts(config) {
-    return {
-        ...getCommonPackageScripts(),
-        ...getCjsScripts(config),
-        ...getEsmScripts(config),
-    };
-}
-function getCjsScripts({ moduleKind }) {
-    if (moduleKind !== "cjs") {
-        return {};
-    }
-    return {
-        build: "npm run clean && tsc && npm run extract-api",
-    };
-}
-function getEsmScripts({ moduleKind }) {
-    if (moduleKind !== "esm") {
-        return {};
-    }
-    return {
-        build: "npm run clean && tshy && npm run extract-api",
-    };
-}
-//# sourceMappingURL=build-flavorless-package.js.map