@azure-tools/typespec-ts 0.54.0 → 0.55.0-dev.6

package/src/modular/serialization/serializeUtils.ts

@@ -1,9 +1,9 @@
-import { getAllAncestors } from "../helpers/operationHelpers.js";
 import {
   SdkModelPropertyType,
   SdkModelType,
-  SdkType
+  SdkType,
 } from "@azure-tools/typespec-client-generator-core";
+import { getAllAncestors } from "../helpers/operationHelpers.js";
 import { getDirectSubtypes } from "../helpers/typeHelpers.js";
 
 /**
@@ -14,7 +14,7 @@ import { getDirectSubtypes } from "../helpers/typeHelpers.js";
  */
 export function getAllDiscriminatedValues(
   type: SdkModelType,
-  discriminatorProperty?: SdkModelPropertyType
+  discriminatorProperty?: SdkModelPropertyType,
 ) {
   if (!type.discriminatorValue) {
     return [];
@@ -30,8 +30,7 @@ export function getAllDiscriminatedValues(
     // Check if this model is a subtype of the given discriminator property
     if (
       !!discriminatorProperty &&
-      model.baseModel?.discriminatorProperty?.name ===
-        discriminatorProperty?.name
+      model.baseModel?.discriminatorProperty?.name === discriminatorProperty?.name
     ) {
       values.push(model.discriminatorValue);
       if (model.discriminatorProperty?.name === discriminatorProperty.name) {
@@ -46,10 +45,7 @@ export function getAllDiscriminatedValues(
 
 export function isSupportedSerializeType(type: SdkType): boolean {
   return (
-    type.kind === "model" ||
-    type.kind === "dict" ||
-    type.kind === "array" ||
-    type.kind === "union"
+    type.kind === "model" || type.kind === "dict" || type.kind === "array" || type.kind === "union"
   );
 }
 
@@ -68,7 +64,7 @@ export function isSupportedSerializeType(type: SdkType): boolean {
 const specialVariantMap = new Map<SdkType, boolean>();
 export function isSpecialUnionVariant(
   t: SdkType & { isNonExhaustive?: boolean },
-  variantStack: SdkType[] = []
+  variantStack: SdkType[] = [],
 ): boolean {
   if (variantStack.length <= 0) {
     variantStack.push(t);
@@ -91,15 +87,13 @@ export function isSpecialUnionVariant(
             ancestors.includes(p.type) ||
             (p.type.kind === "array" &&
               p.type.valueType &&
-              (variantStack.includes(p.type.valueType) ||
-                ancestors.includes(p.type.valueType)))
+              (variantStack.includes(p.type.valueType) || ancestors.includes(p.type.valueType)))
           );
         })
         ?.some(
           (p) =>
-            // eslint-disable-next-line
             (p.kind === "property" && p.name !== p.serializedName) ||
-            isSpecialUnionVariant(p.type, [...variantStack, p.type])
+            isSpecialUnionVariant(p.type, [...variantStack, p.type]),
         )) ||
     isPolymorphicUnion(t) ||
     (t.kind === "array" &&
@@ -138,21 +132,17 @@ export function isNormalUnion(t: SdkType): boolean {
 }
 
 export function isDiscriminatedUnion(
-  type: SdkType
+  type: SdkType,
 ): type is SdkModelType & { discriminatorProperty: SdkType } {
   if (!type) {
     return false;
   }
   return Boolean(
-    type?.kind === "model" &&
-    type.discriminatorProperty &&
-    type.discriminatedSubtypes
+    type?.kind === "model" && type.discriminatorProperty && type.discriminatedSubtypes,
   );
 }
 
-export function isSpecialHandledUnion(
-  t: SdkType & { isNonExhaustive?: boolean }
-): boolean {
+export function isSpecialHandledUnion(t: SdkType & { isNonExhaustive?: boolean }): boolean {
   return isDiscriminatedUnion(t!) || isPolymorphicUnion(t);
 }
 
@@ -210,7 +200,7 @@ export interface ModelOverrideOptions {
 
 export function getPropertyWithOverrides(
   property: SdkModelPropertyType,
-  overrides?: ModelOverrideOptions
+  overrides?: ModelOverrideOptions,
 ): SdkModelPropertyType {
   if (!overrides) {
     return property;

package/src/modular/static/rollup.test.config.js

@@ -1,16 +1,13 @@
+import { makeBrowserTestConfig, makeConfig } from "@azure/dev-tool/shared-config/rollup";
 import cjs from "@rollup/plugin-commonjs";
 import inject from "@rollup/plugin-inject";
 import json from "@rollup/plugin-json";
 import multiEntry from "@rollup/plugin-multi-entry";
 import nodeResolve from "@rollup/plugin-node-resolve";
 import replace from "@rollup/plugin-replace";
+import typescript from "@rollup/plugin-typescript";
 import shim from "rollup-plugin-shim";
 import sourcemaps from "rollup-plugin-sourcemaps";
-import typescript from "@rollup/plugin-typescript";
-import {
-  makeConfig,
-  makeBrowserTestConfig
-} from "@azure/dev-tool/shared-config/rollup";
 
 const inputs = makeConfig(require("./package.json"));
 
@@ -26,7 +23,7 @@ function makeBrowserTestConfigPatch() {
   config.plugins = [
     multiEntry({ exports: false }),
     typescript({
-      exclude: ["test/**/*.spec.ts"]
+      exclude: ["test/**/*.spec.ts"],
     }),
     sourcemaps(),
     replace({
@@ -36,29 +33,29 @@ function makeBrowserTestConfigPatch() {
       // browser only. Rollup's dead code elimination will remove
       // any code guarded by if (isNode) { ... }
       "if (isNode)": "if (false)",
-      "if (!isNode)": "if (true)"
+      "if (!isNode)": "if (true)",
     }),
     // fs, net, and tls are used by rhea and need to be shimmed
     // dotenv doesn't work in the browser, so replace it with a no-op function
     shim({
-      dotenv: `export function config() { }`
+      dotenv: `export function config() { }`,
     }),
     nodeResolve({
       mainFields: ["module", "browser"],
-      preferBuiltins: false
+      preferBuiltins: false,
     }),
     cjs({
       namedExports: {
-        chai: ["should", "assert"]
-      }
+        chai: ["should", "assert"],
+      },
     }),
     inject({
       modules: {
-        process: "process"
+        process: "process",
       },
-      exclude: ["./**/package.json"]
+      exclude: ["./**/package.json"],
     }),
-    json()
+    json(),
   ];
 
   return config;

package/src/modular/static/scripts/renameOutput.mjs

@@ -5,7 +5,7 @@ import * as fs from "fs";
 import * as path from "path";
 import * as url from "url";
 
-const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 const destinationPath = path.join(__dirname, "../dist/");
 
 const inputFile = path.join(destinationPath, "index.js");
@@ -14,4 +14,4 @@ const inputMapFile = path.join(destinationPath, "index.js.map");
 if (fs.existsSync(inputFile) && fs.existsSync(inputMapFile)) {
   fs.renameSync(inputFile, path.join(destinationPath, "index.cjs"));
   fs.renameSync(inputMapFile, path.join(destinationPath, "index.cjs.map"));
-}
+}

package/src/modular/static-helpers-metadata.ts

@@ -2,275 +2,275 @@ export const SerializationHelpers = {
   buildMultiCollection: {
     kind: "function",
     name: "buildMultiCollection",
-    location: "serialization/build-multi-collection.ts"
+    location: "serialization/build-multi-collection.ts",
   },
   buildCsvCollection: {
     kind: "function",
     name: "buildCsvCollection",
-    location: "serialization/build-csv-collection.ts"
+    location: "serialization/build-csv-collection.ts",
   },
   buildPipeCollection: {
     kind: "function",
     name: "buildPipeCollection",
-    location: "serialization/build-pipe-collection.ts"
+    location: "serialization/build-pipe-collection.ts",
   },
   buildSsvCollection: {
     kind: "function",
     name: "buildSsvCollection",
-    location: "serialization/build-ssv-collection.ts"
+    location: "serialization/build-ssv-collection.ts",
   },
   buildTsvCollection: {
     kind: "function",
     name: "buildTsvCollection",
-    location: "serialization/build-tsv-collection.ts"
+    location: "serialization/build-tsv-collection.ts",
   },
   buildNewlineCollection: {
     kind: "function",
     name: "buildNewlineCollection",
-    location: "serialization/build-newline-collection.ts"
+    location: "serialization/build-newline-collection.ts",
   },
   parseCsvCollection: {
     kind: "function",
     name: "parseCsvCollection",
-    location: "serialization/parse-csv-collection.ts"
+    location: "serialization/parse-csv-collection.ts",
   },
   parsePipeCollection: {
     kind: "function",
     name: "parsePipeCollection",
-    location: "serialization/parse-pipe-collection.ts"
+    location: "serialization/parse-pipe-collection.ts",
   },
   parseSsvCollection: {
     kind: "function",
     name: "parseSsvCollection",
-    location: "serialization/parse-ssv-collection.ts"
+    location: "serialization/parse-ssv-collection.ts",
   },
   parseNewlineCollection: {
     kind: "function",
     name: "parseNewlineCollection",
-    location: "serialization/parse-newline-collection.ts"
+    location: "serialization/parse-newline-collection.ts",
   },
   serializeRecord: {
     kind: "function",
     name: "serializeRecord",
-    location: "serialization/serialize-record.ts"
+    location: "serialization/serialize-record.ts",
   },
   getBinaryResponse: {
     kind: "function",
     name: "getBinaryResponse",
-    location: "serialization/get-binary-response.ts"
+    location: "serialization/get-binary-response.ts",
   },
   getBinaryStreamResponse: {
     kind: "function",
     name: "getBinaryStreamResponse",
-    location: "serialization/get-binary-stream-response.ts"
+    location: "serialization/get-binary-stream-response.ts",
   },
   areAllPropsUndefined: {
     kind: "function",
     name: "areAllPropsUndefined",
-    location: "serialization/check-prop-undefined.ts"
-  }
+    location: "serialization/check-prop-undefined.ts",
+  },
 } as const;
 
 export const PagingHelpers = {
   PageSettings: {
     kind: "interface",
     name: "PageSettings",
-    location: "pagingHelpers.ts"
+    location: "pagingHelpers.ts",
   },
   ContinuablePage: {
     kind: "typeAlias",
     name: "ContinuablePage",
-    location: "pagingHelpers.ts"
+    location: "pagingHelpers.ts",
   },
   PagedAsyncIterableIterator: {
     kind: "interface",
     name: "PagedAsyncIterableIterator",
-    location: "pagingHelpers.ts"
+    location: "pagingHelpers.ts",
   },
   PagedResult: {
     kind: "interface",
     name: "PagedResult",
-    location: "pagingHelpers.ts"
+    location: "pagingHelpers.ts",
   },
   BuildPagedAsyncIteratorOptions: {
     kind: "interface",
     name: "BuildPagedAsyncIteratorOptions",
-    location: "pagingHelpers.ts"
+    location: "pagingHelpers.ts",
   },
   BuildPagedAsyncIterator: {
     kind: "function",
     name: "buildPagedAsyncIterator",
-    location: "pagingHelpers.ts"
-  }
+    location: "pagingHelpers.ts",
+  },
 } as const;
 
 export const PollingHelpers = {
   GetLongRunningPollerOptions: {
     kind: "interface",
     name: "GetLongRunningPollerOptions",
-    location: "pollingHelpers.ts"
+    location: "pollingHelpers.ts",
   },
   GetLongRunningPoller: {
     kind: "function",
     name: "getLongRunningPoller",
-    location: "pollingHelpers.ts"
-  }
+    location: "pollingHelpers.ts",
+  },
 } as const;
 
 export const SimplePollerHelpers = {
   SimplePollerLike: {
     kind: "interface",
     name: "SimplePollerLike",
-    location: "simplePollerHelpers.ts"
+    location: "simplePollerHelpers.ts",
   },
   getSimplePoller: {
     kind: "function",
     name: "getSimplePoller",
-    location: "simplePollerHelpers.ts"
-  }
+    location: "simplePollerHelpers.ts",
+  },
 } as const;
 
 export const UrlTemplateHelpers = {
   parseTemplate: {
     kind: "function",
     name: "expandUrlTemplate",
-    location: "urlTemplate.ts"
-  }
+    location: "urlTemplate.ts",
+  },
 } as const;
 export const MultipartHelpers = {
   FileContents: {
     kind: "typeAlias",
     name: "FileContents",
-    location: "multipartHelpers.ts"
+    location: "multipartHelpers.ts",
   },
   createFilePartDescriptor: {
     kind: "function",
     name: "createFilePartDescriptor",
-    location: "multipartHelpers.ts"
-  }
+    location: "multipartHelpers.ts",
+  },
 } as const;
 
 export const PlatformTypeHelpers = {
   NodeReadableStream: {
     kind: "typeAlias",
     name: "NodeReadableStream",
-    location: "platform-types.ts"
-  }
+    location: "platform-types.ts",
+  },
 } as const;
 
 export const CloudSettingHelpers = {
   AzureClouds: {
     kind: "enum",
     name: "AzureClouds",
-    location: "cloudSettingHelpers.ts"
+    location: "cloudSettingHelpers.ts",
   },
   AzureSupportedClouds: {
     kind: "typeAlias",
     name: "AzureSupportedClouds",
-    location: "cloudSettingHelpers.ts"
+    location: "cloudSettingHelpers.ts",
   },
   getArmEndpoint: {
     kind: "function",
     name: "getArmEndpoint",
-    location: "cloudSettingHelpers.ts"
-  }
+    location: "cloudSettingHelpers.ts",
+  },
 } as const;
 
 export const CreateRecorderHelpers = {
   createRecorder: {
     kind: "function",
     name: "createRecorder",
-    location: "recordedClient.ts"
-  }
+    location: "recordedClient.ts",
+  },
 } as const;
 
 export const XmlHelpers = {
   XmlSerializationOptions: {
     kind: "interface",
     name: "XmlSerializationOptions",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   XmlPropertyMetadata: {
     kind: "interface",
     name: "XmlPropertyMetadata",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   XmlPropertyDeserializeMetadata: {
     kind: "interface",
     name: "XmlPropertyDeserializeMetadata",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   XmlAdditionalPropertiesConfig: {
     kind: "interface",
     name: "XmlAdditionalPropertiesConfig",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   serializeModelToXml: {
     kind: "function",
     name: "serializeModelToXml",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   serializeToXml: {
     kind: "function",
     name: "serializeToXml",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   xmlObjectToString: {
     kind: "function",
     name: "xmlObjectToString",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   parseXmlString: {
     kind: "function",
     name: "parseXmlString",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   deserializeXmlToModel: {
     kind: "function",
     name: "deserializeXmlToModel",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   deserializeFromXml: {
     kind: "function",
     name: "deserializeFromXml",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   deserializeXmlObject: {
     kind: "function",
     name: "deserializeXmlObject",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   isXmlContentType: {
     kind: "function",
     name: "isXmlContentType",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   isJsonContentType: {
     kind: "function",
     name: "isJsonContentType",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   XmlSerializedObject: {
     kind: "interface",
     name: "XmlSerializedObject",
-    location: "serialization/xml-helpers.ts"
-  }
+    location: "serialization/xml-helpers.ts",
+  },
 } as const;
 
 export const StorageCompatHelpers = {
   StorageCompatResponseInfo: {
     kind: "interface",
     name: "StorageCompatResponseInfo",
-    location: "storageCompatResponse.ts"
+    location: "storageCompatResponse.ts",
   },
   createStorageCompatOnResponse: {
     kind: "function",
     name: "createStorageCompatOnResponse",
-    location: "storageCompatResponse.ts"
+    location: "storageCompatResponse.ts",
   },
   addStorageCompatResponse: {
     kind: "function",
     name: "addStorageCompatResponse",
-    location: "storageCompatResponse.ts"
-  }
+    location: "storageCompatResponse.ts",
+  },
 } as const;

package/src/modular/type-expressions/get-credential-expression.ts

@@ -1,6 +1,6 @@
 import { SdkCredentialType } from "@azure-tools/typespec-client-generator-core";
-import { resolveReference } from "../../framework/reference.js";
 import { useDependencies } from "../../framework/hooks/useDependencies.js";
+import { resolveReference } from "../../framework/reference.js";
 
 export function getCredentialExpression(type: SdkCredentialType): string {
   const dependencies = useDependencies();

package/src/modular/type-expressions/get-enum-expression.ts

@@ -1,13 +1,13 @@
 import { SdkEnumType } from "@azure-tools/typespec-client-generator-core";
 import { resolveReference } from "../../framework/reference.js";
-import { getTypeExpression, EmitTypeOptions } from "./get-type-expression.js";
-import { shouldEmitInline } from "./utils.js";
 import { SdkContext } from "../../utils/interfaces.js";
+import { EmitTypeOptions, getTypeExpression } from "./get-type-expression.js";
+import { shouldEmitInline } from "./utils.js";
 
 export function getEnumExpression(
   context: SdkContext,
   type: SdkEnumType,
-  options: EmitTypeOptions = {}
+  options: EmitTypeOptions = {},
 ): string {
   if (shouldEmitInline(type, options)) {
     return !isExtensibleEnum(context, type)
@@ -18,11 +18,6 @@ export function getEnumExpression(
   }
 }
 
-export function isExtensibleEnum(
-  context: SdkContext,
-  type: SdkEnumType
-): boolean {
-  return (
-    !type.isFixed && context.rlcOptions?.experimentalExtensibleEnums === true
-  );
+export function isExtensibleEnum(context: SdkContext, type: SdkEnumType): boolean {
+  return !type.isFixed && context.rlcOptions?.experimentalExtensibleEnums === true;
 }

package/src/modular/type-expressions/get-model-expression.ts

@@ -1,20 +1,20 @@
 import {
   EmitTypeOptions,
   getTypeExpression,
-  normalizeModelPropertyName
+  normalizeModelPropertyName,
 } from "./get-type-expression.js";
 
 import {
   SdkModelPropertyType,
   SdkModelType,
-  SdkServiceResponseHeader
+  SdkServiceResponseHeader,
 } from "@azure-tools/typespec-client-generator-core";
-import { refkey } from "../../framework/refkey.js";
-import { resolveReference } from "../../framework/reference.js";
-import { shouldEmitInline } from "./utils.js";
 import { useContext } from "../../contextManager.js";
+import { resolveReference } from "../../framework/reference.js";
+import { refkey } from "../../framework/refkey.js";
 import { SdkContext } from "../../utils/interfaces.js";
 import { MultipartHelpers } from "../static-helpers-metadata.js";
+import { shouldEmitInline } from "./utils.js";
 
 export interface ModelExpressionOptions extends EmitTypeOptions {
   skipPolymorphicUnion?: boolean;
@@ -23,7 +23,7 @@ export interface ModelExpressionOptions extends EmitTypeOptions {
 export function getModelExpression(
   context: SdkContext,
   type: SdkModelType,
-  options: ModelExpressionOptions = {}
+  options: ModelExpressionOptions = {},
 ): string {
   const externalModel = getExternalModel(type);
   if (externalModel) {
@@ -43,12 +43,12 @@ export function getModelExpression(
 
 const externalModels: Record<string, string> = {
   "Azure.Core.Foundations.Error": "ErrorModel",
-  "Azure.Core.Foundations.ErrorResponse": "AzureCoreErrorResponse"
+  "Azure.Core.Foundations.ErrorResponse": "AzureCoreErrorResponse",
 };
 
 export function emitInlineModel(
   context: SdkContext,
-  properties: (SdkModelPropertyType | SdkServiceResponseHeader)[]
+  properties: (SdkModelPropertyType | SdkServiceResponseHeader)[],
 ): string {
   // generate Record<string, any> for empty anonymous object
   if (properties.length === 0) {
@@ -58,7 +58,7 @@ export function emitInlineModel(
       ${properties
         .map(
           (p) =>
-            `${normalizeModelPropertyName(context, p)}${p.optional ? "?" : ""}: ${getPropertyTypeExpression(context, p)}`
+            `${normalizeModelPropertyName(context, p)}${p.optional ? "?" : ""}: ${getPropertyTypeExpression(context, p)}`,
         )
         .join(",\n")}
     }`;
@@ -66,12 +66,9 @@ export function emitInlineModel(
 
 function getPropertyTypeExpression(
   context: SdkContext,
-  property: SdkModelPropertyType | SdkServiceResponseHeader
+  property: SdkModelPropertyType | SdkServiceResponseHeader,
 ): string {
-  if (
-    property.kind === "property" &&
-    property.serializationOptions.multipart?.isFilePart
-  ) {
+  if (property.kind === "property" && property.serializationOptions.multipart?.isFilePart) {
     return getMultipartFileTypeExpression(context, property);
   }
   return getTypeExpression(context, property.type);
@@ -79,7 +76,7 @@ function getPropertyTypeExpression(
 
 export function getMultipartFileTypeExpression(
   context: SdkContext,
-  property: SdkModelPropertyType
+  property: SdkModelPropertyType,
 ): string {
   const multipartOptions = property.serializationOptions.multipart;
 
@@ -88,8 +85,7 @@ export function getMultipartFileTypeExpression(
     multipartOptions.contentType.optional ||
     multipartOptions.defaultContentTypes.length > 0;
   const isFilenameOptional =
-    multipartOptions?.filename === undefined ||
-    multipartOptions.filename.optional;
+    multipartOptions?.filename === undefined || multipartOptions.filename.optional;
 
   const contentTypeType = multipartOptions?.contentType
     ? getTypeExpression(context, multipartOptions.contentType.type)

package/src/modular/type-expressions/get-nullable-expression.ts

@@ -1,18 +1,17 @@
 import { SdkNullableType } from "@azure-tools/typespec-client-generator-core";
 import { resolveReference } from "../../framework/reference.js";
-import { getTypeExpression, EmitTypeOptions } from "./get-type-expression.js";
-import { shouldEmitInline } from "./utils.js";
 import { SdkContext } from "../../utils/interfaces.js";
+import { EmitTypeOptions, getTypeExpression } from "./get-type-expression.js";
+import { shouldEmitInline } from "./utils.js";
 
 export function getNullableExpression(
   context: SdkContext,
   type: SdkNullableType,
-  options: EmitTypeOptions = {}
+  options: EmitTypeOptions = {},
 ): string {
   if (shouldEmitInline(type, options)) {
     // Check if we should ignore null for optional properties
-    const ignoreNullableOnOptional =
-      context.rlcOptions?.ignoreNullableOnOptional ?? false;
+    const ignoreNullableOnOptional = context.rlcOptions?.ignoreNullableOnOptional ?? false;
     const isOptional = options.isOptional ?? false;
 
     const nonNullableType = getTypeExpression(context, type.type, options);