@azure-tools/typespec-ts 0.54.0 → 0.54.2

package/src/rlc-common/helpers/nameConstructors.ts

@@ -1,144 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import { RLCModel } from "../interfaces.js";
-import { NameType, normalizeName } from "./nameUtils.js";
-
-/**
- * Get the response type name by baseName or operatioName & statusCode
- * @param baseResponseName
- */
-export function getResponseTypeName(baseResponseName: string): string;
-export function getResponseTypeName(
-  operationGroup: string,
-  operationName: string,
-  statusCode: string
-): string;
-export function getResponseTypeName(
-  baseNameOrOperationGroup: string,
-  operationName?: string,
-  statusCode?: string
-): string {
-  if (operationName) {
-    baseNameOrOperationGroup = getResponseBaseName(
-      baseNameOrOperationGroup,
-      operationName!,
-      statusCode || ""
-    );
-  }
-  return normalizeName(
-    `${baseNameOrOperationGroup}Response`,
-    NameType.Interface
-  );
-}
-
-export function getLroLogicalResponseName(
-  operationGroup: string,
-  operationName: string
-) {
-  return normalizeName(
-    `${operationGroup}_${operationName}_Logical_Response`,
-    NameType.Interface
-  );
-}
-
-/**
- * The prefix of all response types
- * @param operationGroup operation group name e.g string_PutEmpty
- * @param operationName operation name D e.g string_PutEmpty
- * @param statusCode 2XX, 4XX, 5XX, default etc.
- * @returns normolized base name e.g StringPutEmpty200
- */
-export function getResponseBaseName(
-  operationGroup: string,
-  operationName: string,
-  statusCode: string
-) {
-  return normalizeName(
-    `${operationGroup}_${normalizeName(
-      operationName,
-      NameType.Interface,
-      true
-    )}_${statusCode}`,
-    NameType.Interface
-  );
-}
-
-/**
- * The prefix of all parameter relevant types
- * @param operationName is composed with operationGroup and operationID e.g string_PutEmpty
- * @returns
- */
-export function getParameterBaseName(
-  operationGroup: string,
-  operationName: string
-) {
-  return normalizeName(
-    `${operationGroup}_${operationName}`,
-    NameType.Interface
-  );
-}
-
-/**
- * Get the top-layer parameter name
- * @param operationGroup operation group name
- * @param operationName is composed with operationGroup and operationID e.g string_PutEmpty
- * @returns top-layer parameter name e.g StringPutEmptParameters
- */
-export function getParameterTypeName(baseName: string): string;
-export function getParameterTypeName(
-  operationGroup: string,
-  operationName: string
-): string;
-export function getParameterTypeName(
-  baseNameOrOperationGroup: string,
-  operationName?: string
-) {
-  if (operationName) {
-    baseNameOrOperationGroup = getParameterBaseName(
-      baseNameOrOperationGroup,
-      operationName!
-    );
-  }
-
-  return normalizeName(
-    `${baseNameOrOperationGroup}_Parameters`,
-    NameType.Interface
-  );
-}
-
-export interface ModuleName {
-  esModulesName: string;
-  cjsName: string;
-}
-/**
- * This is a helper function that gets the right import module depending on the type of
- * library being generated
- */
-export function getImportModuleName(name: ModuleName, codeModel: RLCModel) {
-  if (codeModel.options?.moduleKind === "cjs") {
-    return name.cjsName;
-  }
-  return name.esModulesName;
-}
-
-export function getClientName(model: RLCModel) {
-  const clientName = model.libraryName;
-  const clientInterfaceName = model.options?.isModularLibrary
-    ? model.libraryName
-    : clientName.endsWith("Client")
-      ? `${clientName}`
-      : `${clientName}Client`;
-
-  return clientInterfaceName;
-}
-
-export function getMultipartPartTypeName(schemaName: string, partName: string) {
-  const name = normalizeName(partName, NameType.Interface);
-  const bodyParamName = normalizeName(schemaName, NameType.Interface);
-
-  return normalizeName(
-    `${bodyParamName}_${name}_PartDescriptor`,
-    NameType.Interface
-  );
-}

package/src/rlc-common/helpers/nameUtils.ts

@@ -1,319 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-export interface NormalizeNameOption {
-  shouldGuard?: boolean;
-  customReservedNames?: ReservedName[];
-  casingOverride?: CasingConvention;
-  numberPrefixOverride?: string;
-}
-
-export interface ReservedName {
-  name: string;
-  reservedFor: NameType[];
-}
-
-export enum NameType {
-  Class,
-  File,
-  Interface,
-  Property,
-  Parameter,
-  Operation,
-  OperationGroup,
-  Method,
-  EnumMemberName
-}
-
-const Newable = [NameType.Class, NameType.Interface, NameType.OperationGroup];
-
-export const ReservedModelNames: ReservedName[] = [
-  { name: "any", reservedFor: [NameType.Parameter] },
-  { name: "as", reservedFor: [NameType.Parameter] },
-  { name: "assert", reservedFor: [NameType.Parameter] },
-  { name: "async", reservedFor: [NameType.Parameter] },
-  { name: "await", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "boolean", reservedFor: [NameType.Parameter, ...Newable] },
-  { name: "break", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "case", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "catch", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "class", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "const", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "constructor", reservedFor: [NameType.Parameter] },
-  { name: "continue", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "date", reservedFor: [NameType.Parameter, ...Newable] },
-  { name: "debugger", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "declare", reservedFor: [NameType.Parameter] },
-  { name: "default", reservedFor: [NameType.Parameter, NameType.Method] },
-  {
-    name: "delete",
-    reservedFor: [NameType.Parameter, NameType.Operation, NameType.Method]
-  },
-  { name: "do", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "else", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "enum", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "error", reservedFor: [NameType.Parameter, ...Newable] },
-  {
-    name: "export",
-    reservedFor: [NameType.Parameter, NameType.Operation, NameType.Method]
-  },
-  { name: "extends", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "false", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "finally", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "for", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "from", reservedFor: [NameType.Parameter] },
-  {
-    name: "function",
-    reservedFor: [NameType.Parameter, ...Newable, NameType.Method]
-  },
-  { name: "get", reservedFor: [NameType.Parameter] },
-  { name: "if", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "implements", reservedFor: [NameType.Parameter] },
-  { name: "import", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "in", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "instanceof", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "interface", reservedFor: [NameType.Parameter] },
-  { name: "let", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "module", reservedFor: [NameType.Parameter] },
-  { name: "new", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "null", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "number", reservedFor: [NameType.Parameter, ...Newable] },
-  { name: "of", reservedFor: [NameType.Parameter] },
-  { name: "package", reservedFor: [NameType.Parameter] },
-  { name: "private", reservedFor: [NameType.Parameter] },
-  { name: "protected", reservedFor: [NameType.Parameter] },
-  {
-    name: "public",
-    reservedFor: [NameType.Parameter, NameType.Operation, NameType.Method]
-  },
-  { name: "requestoptions", reservedFor: [NameType.Parameter] },
-  { name: "require", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "return", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "set", reservedFor: [NameType.Parameter, ...Newable] },
-  { name: "static", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "string", reservedFor: [NameType.Parameter, ...Newable] },
-  { name: "super", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "switch", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "symbol", reservedFor: [NameType.Parameter, ...Newable] },
-  { name: "this", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "throw", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "true", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "try", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "type", reservedFor: [NameType.Parameter] },
-  { name: "typeof", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "var", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "void", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "while", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "with", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "yield", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "arguments", reservedFor: [NameType.Parameter, NameType.Method] },
-  { name: "global", reservedFor: [...Newable] },
-  // reserve client for codegen
-  { name: "client", reservedFor: [NameType.Parameter] },
-  { name: "endpoint", reservedFor: [NameType.Parameter] },
-  { name: "apiVersion", reservedFor: [NameType.Parameter] }
-];
-
-export enum CasingConvention {
-  Pascal,
-  Camel
-}
-
-export function guardReservedNames(
-  name: string,
-  nameType: NameType,
-  customReservedNames: ReservedName[] = []
-): string {
-  const [prefix, suffix] = getAffix(nameType);
-  return [...ReservedModelNames, ...customReservedNames]
-    .filter((r) => r.reservedFor.includes(nameType))
-    .find((r) => r.name === name.toLowerCase())
-    ? `${prefix}${name}${suffix}`
-    : name;
-}
-
-function getAffix(nameType?: NameType): [string, string] {
-  switch (nameType) {
-    case NameType.File:
-    case NameType.Operation:
-      return ["", ""];
-    case NameType.Property:
-      return ["", "Property"];
-    case NameType.OperationGroup:
-      return ["", "Operations"];
-    case NameType.Parameter:
-      return ["", "Param"];
-    case NameType.Method:
-      return ["$", ""];
-    case NameType.Class:
-    case NameType.Interface:
-    default:
-      return ["", "Model"];
-  }
-}
-
-export function normalizeName(
-  name: string,
-  nameType: NameType,
-  shouldGuard?: boolean,
-  customReservedNames?: ReservedName[],
-  casingOverride?: CasingConvention,
-  oriName?: string
-): string;
-export function normalizeName(
-  name: string,
-  nameType: NameType,
-  options?: NormalizeNameOption
-): string;
-export function normalizeName(
-  name: string,
-  nameType: NameType,
-  optionsOrShouldGuard?: NormalizeNameOption | boolean,
-  optionalCustomReservedNames?: ReservedName[],
-  optionalCasingOverride?: CasingConvention,
-  oriName?: string
-): string {
-  let shouldGuard: boolean | undefined,
-    customReservedNames: ReservedName[],
-    casingOverride: CasingConvention | undefined,
-    numberPrefixOverride: string | undefined;
-  if (typeof optionsOrShouldGuard === "boolean") {
-    shouldGuard = optionsOrShouldGuard;
-    customReservedNames = optionalCustomReservedNames ?? [];
-    casingOverride = optionalCasingOverride;
-  } else {
-    shouldGuard = optionsOrShouldGuard?.shouldGuard;
-    customReservedNames = optionsOrShouldGuard?.customReservedNames ?? [];
-    casingOverride = optionsOrShouldGuard?.casingOverride;
-    numberPrefixOverride = optionsOrShouldGuard?.numberPrefixOverride;
-  }
-  if ((oriName ?? name).startsWith("$DO_NOT_NORMALIZE$")) {
-    return (oriName ?? name).replace("$DO_NOT_NORMALIZE$", "");
-  }
-  const casingConvention = casingOverride ?? getCasingConvention(nameType);
-  const parts = deconstruct(name);
-  if (parts.length === 0) {
-    return name;
-  }
-  const [firstPart, ...otherParts] = parts;
-  const normalizedFirstPart = toCasing(firstPart ?? "", casingConvention, true);
-  const normalizedParts = (otherParts || [])
-    .map((part) => toCasing(part, CasingConvention.Pascal))
-    .join("");
-
-  const normalized = `${normalizedFirstPart}${normalizedParts}`;
-  const result = shouldGuard
-    ? guardReservedNames(normalized, nameType, customReservedNames)
-    : normalized;
-  return fixLeadingNumber(result, nameType, numberPrefixOverride);
-}
-
-export function fixLeadingNumber(
-  name: string,
-  nameType: NameType,
-  prefix: string = "_"
-): string {
-  const casingConvention = getCasingConvention(nameType);
-  if (!name || !name.match(/^[-.]?\d/)) {
-    return name;
-  }
-  return `${toCasing(prefix, casingConvention)}${name}`;
-}
-
-function isFullyUpperCase(
-  identifier: string,
-  maxUppercasePreserve: number = 3
-) {
-  const len = identifier.length;
-  if (len > 1) {
-    if (
-      len <= maxUppercasePreserve &&
-      identifier === identifier.toUpperCase()
-    ) {
-      return true;
-    }
-
-    if (len <= maxUppercasePreserve + 1 && identifier.endsWith("s")) {
-      const i = identifier.substring(0, len - 1);
-      if (i.toUpperCase() === i) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-function deconstruct(identifier: string): Array<string> {
-  return `${identifier}`
-    .replace(/([a-z]+)([A-Z])/g, "$1 $2") // Add a space in between camelCase words(e.g. fooBar => foo Bar)
-    .replace(/(\d+)/g, " $1 ") // Adds a space after numbers(e.g. foo123Bar => foo123 bar)
-    .replace(/_/g, " ") // Replace underscores with spaces
-    .replace(/\b([A-Z]+)([A-Z])s([^a-z])(.*)/g, "$1$2« $3$4") // Add a space after a plural upper cased word(e.g. MBsFoo => MBs Foo)
-    .replace(/\b([A-Z]+)([A-Z])([a-z]+)/g, "$1 $2$3") // Add a space between an upper case word(2 char+) and the last captial case.(e.g. SQLConnection -> SQL Connection)
-    .replace(/«/g, "s")
-    .trim()
-    .split(/[\W|_]+/)
-    .map((each) => (isFullyUpperCase(each) ? each : each.toLowerCase()))
-    .filter((part) => !!part);
-}
-
-export function getModelsName(title: string): string {
-  const spaceRemovedTitle = title.replace(/ /g, "");
-  return `${spaceRemovedTitle.replace("Client", "")}Models`;
-}
-
-export function getMappersName(title: string): string {
-  const spaceRemovedTitle = title.replace(/ /g, "");
-  return `${spaceRemovedTitle.replace("Client", "")}Mappers`;
-}
-
-function getCasingConvention(nameType: NameType) {
-  switch (nameType) {
-    case NameType.Class:
-    case NameType.Interface:
-    case NameType.OperationGroup:
-    case NameType.EnumMemberName:
-      return CasingConvention.Pascal;
-    case NameType.File:
-    case NameType.Property:
-    case NameType.Operation:
-    case NameType.Parameter:
-    case NameType.Method:
-      return CasingConvention.Camel;
-  }
-}
-
-function toCasing(
-  str: string,
-  casing: CasingConvention,
-  keepConsistent = false
-): string {
-  const firstChar =
-    casing === CasingConvention.Pascal
-      ? str.charAt(0).toUpperCase()
-      : str.charAt(0).toLowerCase();
-  const allLowerCases =
-    casing !== CasingConvention.Pascal &&
-    keepConsistent &&
-    str.toUpperCase() === str;
-  return allLowerCases ? str.toLowerCase() : `${firstChar}${str.substring(1)}`;
-}
-
-export function pascalCase(str: string) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-
-export function camelCase(
-  str: string,
-  options: { uppercaseThreshold?: number } = {}
-) {
-  const { uppercaseThreshold = 4 } = options;
-  const thresholdRegex = new RegExp(
-    `^(?<![A-Z])[A-Z]{1,${uppercaseThreshold}}(?![A-Z])`
-  );
-  if (!thresholdRegex.test(str)) {
-    return str;
-  }
-
-  return str.charAt(0).toLowerCase() + str.slice(1);
-}

package/src/rlc-common/helpers/operationHelpers.ts

@@ -1,155 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import {
-  MethodSignatureStructure,
-  OptionalKind,
-  ParameterDeclarationStructure
-} from "ts-morph";
-import {
-  Methods,
-  ObjectSchema,
-  ParameterMetadata,
-  PathParameter,
-  RLCModel,
-  Schema,
-  SchemaContext
-} from "../interfaces.js";
-import { NameType, normalizeName, pascalCase } from "./nameUtils.js";
-import { isObjectSchema } from "./schemaHelpers.js";
-
-export function buildMethodDefinitions(
-  methods: Methods,
-  pathParams: PathParameter[] = []
-): OptionalKind<MethodSignatureStructure>[] {
-  const methodDefinitions: OptionalKind<MethodSignatureStructure>[] = [];
-  for (const key of Object.keys(methods)) {
-    const verbMethods = methods[key];
-    if (!verbMethods) {
-      continue;
-    }
-    for (const method of verbMethods) {
-      const description = method.description;
-      const areAllOptional = method.hasOptionalOptions;
-
-      methodDefinitions.push({
-        name: key,
-        ...(description && { docs: [{ description }] }),
-        parameters: [
-          ...getPathParamDefinitions(pathParams),
-          {
-            name: "options",
-            hasQuestionToken: areAllOptional,
-            type: pascalCase(method.optionsName)
-          }
-        ],
-        returnType: `StreamableMethod<${method.returnType}>`
-      });
-    }
-  }
-
-  return methodDefinitions;
-}
-
-export function getPathParamDefinitions(
-  pathParams: PathParameter[]
-): OptionalKind<ParameterDeclarationStructure>[] {
-  return pathParams.map(({ name, type, description }) => {
-    return {
-      name: normalizeName(name, NameType.Parameter),
-      type,
-      description
-    };
-  });
-}
-
-export function hasPagingOperations(model: RLCModel) {
-  return Boolean(model.helperDetails?.hasPaging);
-}
-
-export function hasPollingOperations(model: RLCModel) {
-  return Boolean(model.helperDetails?.hasLongRunning);
-}
-
-export function hasMultiCollection(model: RLCModel) {
-  return Boolean(model.helperDetails?.hasMultiCollection);
-}
-
-export function hasPipeCollection(model: RLCModel) {
-  return Boolean(model.helperDetails?.hasPipeCollection);
-}
-
-export function hasSsvCollection(model: RLCModel) {
-  return Boolean(model.helperDetails?.hasSsvCollection);
-}
-
-export function hasTsvCollection(model: RLCModel) {
-  return Boolean(model.helperDetails?.hasTsvCollection);
-}
-
-export function hasCsvCollection(model: RLCModel) {
-  return Boolean(model.helperDetails?.hasCsvCollection);
-}
-
-export function hasUnexpectedHelper(model: RLCModel) {
-  const pathDictionary = model.paths;
-  for (const details of Object.values(pathDictionary)) {
-    for (const methodDetails of Object.values(details.methods)) {
-      const firstMethod = methodDetails[0];
-      if (!firstMethod) {
-        continue;
-      }
-      const successTypes = firstMethod.responseTypes.success;
-      const errorTypes = firstMethod.responseTypes.error;
-
-      if (successTypes.length > 0 && errorTypes.length > 0 && !!errorTypes[0]) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-export function hasInputModels(model: RLCModel) {
-  return hasSchemaContextObject(model, [SchemaContext.Input]);
-}
-export function hasOutputModels(model: RLCModel) {
-  return hasSchemaContextObject(model, [
-    SchemaContext.Output,
-    SchemaContext.Exception
-  ]);
-}
-
-function hasSchemaContextObject(model: RLCModel, schemaUsage: SchemaContext[]) {
-  const objectSchemas: ObjectSchema[] = (model.schemas ?? []).filter(
-    (o) =>
-      isObjectSchema(o) &&
-      (o as ObjectSchema).usage?.some((u) => schemaUsage.includes(u))
-  );
-
-  return objectSchemas.length > 0;
-}
-
-export function getGeneratedWrapperTypes(
-  params: ParameterMetadata[] | PathParameter[]
-): Schema[] {
-  const wrapperTypes = params
-    .map((qp) =>
-      isParameterMetadata(qp) ? qp.param.wrapperType : qp.wrapperType
-    )
-    .filter((v) => v !== undefined);
-  const wrapperFromObjects = wrapperTypes.filter(
-    (wrap) => wrap.type === "object"
-  );
-  const wrapperFromUnions = wrapperTypes
-    .filter((wrap) => wrap.type === "union")
-    .flatMap((wrapperType) => wrapperType?.enum ?? [])
-    .filter((v) => v.type === "object");
-  return [...wrapperFromUnions, ...wrapperFromObjects];
-}
-
-function isParameterMetadata(
-  param: ParameterMetadata | PathParameter
-): param is ParameterMetadata {
-  return (param as any).param !== undefined;
-}

package/src/rlc-common/helpers/pathUtils.ts

@@ -1,15 +0,0 @@
-import * as path from "path";
-
-export function getRelativePartFromSrcPath(
-  srcPath: string,
-  isModularLibrary: boolean = false
-) {
-  const sep = srcPath.includes(path.sep + "src") ? path.sep : "/";
-  let relativePart = srcPath.substring(srcPath.indexOf(sep + "src") + 4);
-  if (isModularLibrary) {
-    relativePart = relativePart.substring(srcPath.indexOf(sep + "rest"), +5);
-  }
-  return relativePart.startsWith(sep)
-    ? relativePart.substring(1)
-    : relativePart;
-}

package/src/rlc-common/helpers/schemaHelpers.ts

@@ -1,61 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import {
-  ArraySchema,
-  ObjectSchema,
-  RLCModel,
-  Schema,
-  SchemaContext
-} from "../interfaces.js";
-
-export interface IsDictionaryOptions {
-  filterEmpty?: boolean;
-}
-
-export function isArraySchema(schema: Schema): schema is ArraySchema {
-  return (
-    schema.type === "array" || typeof (schema as any).items !== "undefined"
-  );
-}
-
-export function isDictionarySchema(
-  schema: Schema,
-  options: IsDictionaryOptions = {}
-) {
-  if (schema.type === "dictionary") {
-    if (!options.filterEmpty || (options.filterEmpty && !schema.typeName)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-export function isObjectSchema(schema: Schema): schema is ObjectSchema {
-  if (schema.type === "object") {
-    return true;
-  }
-  return false;
-}
-
-export function isConstantSchema(schema: Schema) {
-  if (schema.type === "constant") {
-    return true;
-  }
-  return false;
-}
-
-export function buildSchemaObjectMap(model: RLCModel) {
-  // include interfaces
-  const map = new Map<string, Schema>();
-  const allSchemas = (model.schemas ?? []).filter(
-    (o) =>
-      isObjectSchema(o) &&
-      (o as ObjectSchema).usage?.some((u) => [SchemaContext.Input].includes(u))
-  );
-  allSchemas.forEach((o) => {
-    map.set(o.name, o);
-  });
-
-  return map;
-}