@ng-openapi/http-resource 0.1.3-pr-127-fix-125-sanitize-generated-identifiers-9082a48.0 → 0.1.3

package/index.cjs

@@ -38,238 +38,6 @@ module.exports = __toCommonJS(index_exports);
 // src/lib/http-resource.generator.ts
 var import_ts_morph = require("ts-morph");
 
-// ../../shared/src/errors.ts
-var NG_OPENAPI_ERROR_BRAND = "__ngOpenApiError";
-var ERROR_LINEAGE = /* @__PURE__ */ new WeakMap();
-var FALLBACK_LINEAGE = Object.freeze([
-  "NgOpenApiError"
-]);
-function registerError(cls, lineage) {
-  ERROR_LINEAGE.set(cls, Object.freeze([
-    ...lineage
-  ]));
-  return cls;
-}
-__name(registerError, "registerError");
-function inheritedLineage(cls) {
-  for (let current = cls; typeof current === "function"; current = Object.getPrototypeOf(current)) {
-    const lineage = ERROR_LINEAGE.get(current);
-    if (lineage) {
-      return lineage;
-    }
-  }
-  return FALLBACK_LINEAGE;
-}
-__name(inheritedLineage, "inheritedLineage");
-var NgOpenApiError = class extends Error {
-  static {
-    __name(this, "NgOpenApiError");
-  }
-  /** The underlying error that caused this one, when there is one. */
-  cause;
-  constructor(message, cause) {
-    super(message);
-    const lineage = inheritedLineage(new.target);
-    this.name = lineage[0];
-    this.cause = cause;
-    Object.defineProperty(this, NG_OPENAPI_ERROR_BRAND, {
-      value: lineage,
-      enumerable: false,
-      writable: false,
-      configurable: false
-    });
-  }
-  /**
-   * `message` and `name` are non-enumerable on Error, so the default
-   * JSON.stringify dropped both — the least useful possible serialization for
-   * something that exists to be logged.
-   *
-   * The payload is spread rather than enumerated: `source`, `issues`,
-   * `operation`, `names` and `placeholders` are why these classes are typed
-   * in the first place, and listing fields by hand silently drops whichever
-   * ones a later subclass adds.
-   */
-  toJSON() {
-    const cause = this.cause instanceof Error ? this.cause.message : this.cause;
-    return {
-      name: this.name,
-      message: this.message,
-      ...cause === void 0 ? {} : {
-        cause
-      },
-      // Own enumerable properties: the brand is deliberately not one.
-      ...Object.fromEntries(Object.entries(this).filter(([key]) => key !== "cause"))
-    };
-  }
-  /**
-   * Recognizes branded errors from another bundled copy of this module, so
-   * `error instanceof SpecLoadError` works for a plugin-thrown error too.
-   * The prototype chain is checked first, so a caller's own subclass of these
-   * classes still matches even though it carries no lineage entry.
-   *
-   * Never throws and never runs foreign code: both reflective reads sit
-   * inside the try, because a Proxy traps `getPrototypeOf` just as readily as
-   * `getOwnPropertyDescriptor`.
-   */
-  static [Symbol.hasInstance](value) {
-    if (typeof value !== "object" || value === null) {
-      return false;
-    }
-    try {
-      if (Object.prototype.isPrototypeOf.call(this.prototype, value)) {
-        return true;
-      }
-      const expected = ERROR_LINEAGE.get(this)?.[0];
-      if (expected === void 0) {
-        return false;
-      }
-      const descriptor = Object.getOwnPropertyDescriptor(value, NG_OPENAPI_ERROR_BRAND);
-      if (!descriptor || descriptor.enumerable || !("value" in descriptor)) {
-        return false;
-      }
-      return Array.isArray(descriptor.value) && descriptor.value.includes(expected);
-    } catch {
-      return false;
-    }
-  }
-};
-registerError(NgOpenApiError, [
-  "NgOpenApiError"
-]);
-var SpecLoadError = class extends NgOpenApiError {
-  static {
-    __name(this, "SpecLoadError");
-  }
-  /** The file path or URL that failed to load. */
-  source;
-  constructor(message, source, cause) {
-    super(message, cause);
-    this.source = source;
-  }
-};
-registerError(SpecLoadError, [
-  "SpecLoadError",
-  "NgOpenApiError"
-]);
-var SpecParseError = class extends NgOpenApiError {
-  static {
-    __name(this, "SpecParseError");
-  }
-  /** The file path or URL the content came from, when known. */
-  source;
-  constructor(message, source, cause) {
-    super(message, cause);
-    this.source = source;
-  }
-};
-registerError(SpecParseError, [
-  "SpecParseError",
-  "NgOpenApiError"
-]);
-function describeOperation(operation) {
-  const location = `(${operation.method}) ${operation.path}`;
-  return operation.operationId ? `${operation.operationId} (${location})` : location;
-}
-__name(describeOperation, "describeOperation");
-function captureOperation(operation) {
-  return Object.freeze({
-    operationId: operation.operationId,
-    method: operation.method,
-    path: operation.path
-  });
-}
-__name(captureOperation, "captureOperation");
-var InvalidIdentifierError = class extends NgOpenApiError {
-  static {
-    __name(this, "InvalidIdentifierError");
-  }
-  /** The rejected name, verbatim; absent when no name could be derived. */
-  identifier;
-  /** The operation whose name was being derived. */
-  operation;
-  constructor(message, operation, identifier) {
-    super(message);
-    this.operation = captureOperation(operation);
-    this.identifier = identifier;
-  }
-};
-registerError(InvalidIdentifierError, [
-  "InvalidIdentifierError",
-  "NgOpenApiError"
-]);
-var DuplicateGeneratedNameError = class extends NgOpenApiError {
-  static {
-    __name(this, "DuplicateGeneratedNameError");
-  }
-  /** The colliding generated names. */
-  names;
-  /** The operations that produced them, when known. */
-  operations;
-  constructor(message, names, operations = []) {
-    super(message);
-    this.names = Object.freeze([
-      ...names
-    ]);
-    this.operations = Object.freeze(operations.map(captureOperation));
-  }
-};
-registerError(DuplicateGeneratedNameError, [
-  "DuplicateGeneratedNameError",
-  "NgOpenApiError"
-]);
-var UnresolvedPathTemplateError = class extends NgOpenApiError {
-  static {
-    __name(this, "UnresolvedPathTemplateError");
-  }
-  /** The path as written in the spec. */
-  path;
-  /** Placeholder names with no declared parameter. */
-  placeholders;
-  constructor(message, path3, placeholders) {
-    super(message);
-    this.path = path3;
-    this.placeholders = Object.freeze([
-      ...placeholders
-    ]);
-  }
-};
-registerError(UnresolvedPathTemplateError, [
-  "UnresolvedPathTemplateError",
-  "NgOpenApiError"
-]);
-var ConfigValidationError = class extends NgOpenApiError {
-  static {
-    __name(this, "ConfigValidationError");
-  }
-  issues;
-  constructor(issues) {
-    super(`Invalid ng-openapi configuration:
-${issues.map((issue) => `  - ${issue}`).join("\n")}`);
-    this.issues = Object.freeze([
-      ...issues
-    ]);
-  }
-};
-registerError(ConfigValidationError, [
-  "ConfigValidationError",
-  "NgOpenApiError"
-]);
-var ConfigLoadError = class extends NgOpenApiError {
-  static {
-    __name(this, "ConfigLoadError");
-  }
-  /** Path of the config file that failed to load. */
-  source;
-  constructor(message, source, cause) {
-    super(message, cause);
-    this.source = source;
-  }
-};
-registerError(ConfigLoadError, [
-  "ConfigLoadError",
-  "NgOpenApiError"
-]);
-
 // ../../../node_modules/js-yaml/dist/js-yaml.mjs
 function isNothing(subject) {
   return typeof subject === "undefined" || subject === null;
@@ -2972,73 +2740,17 @@ var safeLoad = renamed("safeLoad", "load");
 var safeLoadAll = renamed("safeLoadAll", "loadAll");
 var safeDump = renamed("safeDump", "dump");
 
-// ../../shared/src/utils/content-types.constants.ts
-var CONTENT_TYPES = {
-  MULTIPART: "multipart/form-data",
-  FORM_URLENCODED: "application/x-www-form-urlencoded",
-  JSON: "application/json"
-};
-
-// ../../shared/src/emit/literal.emit.ts
-function quoteLiteral(value) {
-  return `'${escapeSingleQuoted(value)}'`;
-}
-__name(quoteLiteral, "quoteLiteral");
-function escapeSingleQuoted(value) {
-  return value.replace(/[\\']/g, (char) => `\\${char}`).replace(/\r/g, "\\r").replace(/\n/g, "\\n");
-}
-__name(escapeSingleQuoted, "escapeSingleQuoted");
-function escapeTemplateLiteral(value) {
-  return value.replace(/[\\`]/g, (char) => `\\${char}`).replace(/\$\{/g, "\\${").replace(/\r/g, "\\r");
-}
-__name(escapeTemplateLiteral, "escapeTemplateLiteral");
-function emitObjectKey(name, quoteStyle = "double") {
-  const quoted = quoteStyle === "single" ? quoteLiteral(name) : `"${escapeDoubleQuoted(name)}"`;
-  return name === "__proto__" ? `[${quoted}]` : quoted;
-}
-__name(emitObjectKey, "emitObjectKey");
-function escapeDoubleQuoted(value) {
-  return value.replace(/[\\"]/g, (char) => `\\${char}`).replace(/\r/g, "\\r").replace(/\n/g, "\\n");
-}
-__name(escapeDoubleQuoted, "escapeDoubleQuoted");
-function escapeJsDoc(text) {
-  return text.replace(/\*\//g, "*\\/");
-}
-__name(escapeJsDoc, "escapeJsDoc");
-function emitDocs(description) {
-  return typeof description === "string" && description ? [
-    escapeJsDoc(description)
-  ] : void 0;
-}
-__name(emitDocs, "emitDocs");
-
 // ../../shared/src/utils/string.utils.ts
-var IDENTIFIER_SEPARATORS = /(?:_|[^\p{ID_Continue}$])+(.)?/gu;
-var INVALID_IDENTIFIER_START = /^[^\p{ID_Start}$_]/u;
-function toIdentifier(converted) {
-  if (converted === "") {
-    return "_";
-  }
-  return converted.replace(INVALID_IDENTIFIER_START, (char) => `_${char}`);
-}
-__name(toIdentifier, "toIdentifier");
-function isValidIdentifier(name) {
-  return /^[\p{ID_Start}$_][\p{ID_Continue}$]*$/u.test(name);
-}
-__name(isValidIdentifier, "isValidIdentifier");
 function camelCase(str2) {
-  const converted = str2.replace(IDENTIFIER_SEPARATORS, (_, char) => char ? char.toUpperCase() : "").replace(/^./u, (char) => char.toLowerCase());
-  return toIdentifier(converted);
+  return str2.replace(/[-_.\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^./, (char) => char.toLowerCase());
 }
 __name(camelCase, "camelCase");
 function pascalCase(str2) {
-  const converted = str2.replace(IDENTIFIER_SEPARATORS, (_, char) => char ? char.toUpperCase() : "").replace(/^./u, (char) => char.toUpperCase());
-  return toIdentifier(converted);
+  return str2.replace(/[-_.\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^./, (char) => char.toUpperCase());
 }
 __name(pascalCase, "pascalCase");
 function pascalCaseForEnums(str2) {
-  const converted = str2.replace(/[^a-zA-Z0-9]/g, "_").replace(/(?:^|_)([a-z])/g, (_, char) => char.toUpperCase()).replace(/^([0-9])/, "_$1");
-  return converted === "" ? "_" : converted;
+  return str2.replace(/[^a-zA-Z0-9]/g, "_").replace(/(?:^|_)([a-z])/g, (_, char) => char.toUpperCase()).replace(/^([0-9])/, "_$1");
 }
 __name(pascalCaseForEnums, "pascalCaseForEnums");
 
@@ -3084,7 +2796,7 @@ function getTypeScriptType(schemaOrType, config, formatOrNullable, isNullable, c
   switch (schema2.type) {
     case "string":
       if (schema2.enum) {
-        return schema2.enum.map((value) => typeof value === "string" ? `'${escapeSingleQuoted(value)}'` : String(value)).join(" | ");
+        return schema2.enum.map((value) => typeof value === "string" ? `'${escapeString2(value)}'` : String(value)).join(" | ");
       }
       if (schema2.format === "date" || schema2.format === "date-time") {
         const dateType = config.options.dateType === "Date" ? "Date" : "string";
@@ -3120,6 +2832,10 @@ function nullableType(type2, isNullable) {
   return type2 + (isNullable ? " | null" : "");
 }
 __name(nullableType, "nullableType");
+function escapeString2(str2) {
+  return str2.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+__name(escapeString2, "escapeString");
 
 // ../../shared/src/utils/functions/extract-swagger-response-type.ts
 function getResponseTypeFromResponse(response, responseTypeMapping) {
@@ -3268,7 +2984,7 @@ __name(getResponseType, "getResponseType");
 
 // ../../shared/src/emit/headers.emit.ts
 function emitDefaultHeadersMerge(optionsExpression, customHeaders) {
-  const defaultsLiteral = Object.entries(customHeaders).map(([key, value]) => `${emitObjectKey(key, "single")}: ${quoteLiteral(value)}`).join(", ");
+  const defaultsLiteral = Object.entries(customHeaders).map(([key, value]) => `'${key}': '${value}'`).join(", ");
   return `
 // Add default headers if not already present
 let headers = ${optionsExpression}?.headers;
@@ -3280,238 +2996,12 @@ ${emitDefaultHeaderGuards(customHeaders)}
 }
 __name(emitDefaultHeadersMerge, "emitDefaultHeadersMerge");
 function emitDefaultHeaderGuards(customHeaders) {
-  return Object.entries(customHeaders).map(([key, value]) => {
-    const name = quoteLiteral(key);
-    return `if (!headers.has(${name})) {
-  headers = headers.set(${name}, ${quoteLiteral(value)});
-}`;
-  }).join("\n");
+  return Object.entries(customHeaders).map(([key, value]) => `if (!headers.has('${key}')) {
+  headers = headers.set('${key}', '${value}');
+}`).join("\n");
 }
 __name(emitDefaultHeaderGuards, "emitDefaultHeaderGuards");
 
-// ../../shared/src/utils/functions/get-request-body-type.ts
-function getRequestBodyType(requestBody, config) {
-  const content = requestBody.content || {};
-  const jsonContent = content[CONTENT_TYPES.JSON];
-  if (jsonContent?.schema) {
-    return getTypeScriptType(jsonContent.schema, config, jsonContent.schema.nullable);
-  }
-  return "any";
-}
-__name(getRequestBodyType, "getRequestBodyType");
-
-// ../../shared/src/utils/functions/is-data-type-interface.ts
-function isDataTypeInterface(type2) {
-  const invalidTypes = [
-    "any",
-    "File",
-    "string",
-    "number",
-    "boolean",
-    "object",
-    "unknown",
-    "[]",
-    "Array"
-  ];
-  return !invalidTypes.some((invalidType) => type2.includes(invalidType));
-}
-__name(isDataTypeInterface, "isDataTypeInterface");
-
-// ../../shared/src/utils/functions/argument-names.ts
-var RESERVED_WORDS = [
-  "arguments",
-  "await",
-  "break",
-  "case",
-  "catch",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "enum",
-  "eval",
-  "export",
-  "extends",
-  "false",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "implements",
-  "import",
-  "in",
-  "instanceof",
-  "interface",
-  "let",
-  "new",
-  "null",
-  "package",
-  "private",
-  "protected",
-  "public",
-  "return",
-  "static",
-  "super",
-  "switch",
-  "this",
-  "throw",
-  "true",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with",
-  "yield"
-];
-var SERVICE_ARGUMENT_PROFILE = Object.freeze({
-  reserved: Object.freeze([
-    "observe",
-    "options",
-    "url",
-    "params",
-    "headers",
-    "formData",
-    "formBody"
-  ]),
-  bindsRequestBody: true
-});
-var RESOURCE_ARGUMENT_PROFILE = Object.freeze({
-  reserved: Object.freeze([
-    "resourceOptions",
-    "requestOptions",
-    "params",
-    "headers"
-  ]),
-  bindsRequestBody: false
-});
-var REQUEST_BODY_KEY = /* @__PURE__ */ Symbol("requestBody");
-function resolveArgumentNames(operation, config, profile) {
-  let byConfig = RESOLVED.get(operation);
-  if (!byConfig) {
-    byConfig = /* @__PURE__ */ new WeakMap();
-    RESOLVED.set(operation, byConfig);
-  }
-  let byProfile = byConfig.get(config);
-  if (!byProfile) {
-    byProfile = /* @__PURE__ */ new WeakMap();
-    byConfig.set(config, byProfile);
-  }
-  const cached = byProfile.get(profile);
-  if (cached) {
-    return cached;
-  }
-  const resolved = computeArgumentNames(operation, config, profile);
-  byProfile.set(profile, resolved);
-  return resolved;
-}
-__name(resolveArgumentNames, "resolveArgumentNames");
-var RESOLVED = /* @__PURE__ */ new WeakMap();
-function computeArgumentNames(operation, config, profile) {
-  const entries = [
-    ...operation.pathParams.map((param) => ({
-      key: param.name,
-      base: camelCase(param.name)
-    })),
-    ...operation.formDataFields.map((field) => ({
-      key: field,
-      base: camelCase(field)
-    })),
-    ...operation.urlEncodedFields.map((field) => ({
-      key: field,
-      base: camelCase(field)
-    }))
-  ];
-  const bodyBase = profile.bindsRequestBody ? jsonBodyIdentifier(operation, config) : void 0;
-  if (bodyBase !== void 0) {
-    entries.push({
-      key: REQUEST_BODY_KEY,
-      base: bodyBase
-    });
-  }
-  entries.push(...operation.queryParams.map((param) => ({
-    key: param.name,
-    base: camelCase(param.name)
-  })));
-  const identifiers = /* @__PURE__ */ new Map();
-  const used = /* @__PURE__ */ new Set([
-    ...profile.reserved,
-    ...RESERVED_WORDS
-  ]);
-  const renamed2 = [];
-  const merged = /* @__PURE__ */ new Set();
-  for (const { key, base } of entries) {
-    if (identifiers.has(key)) {
-      if (typeof key === "string") {
-        merged.add(key);
-      }
-      continue;
-    }
-    let identifier = base;
-    let suffix = 2;
-    while (used.has(identifier)) {
-      identifier = `${base}${suffix}`;
-      suffix++;
-    }
-    if (identifier !== base) {
-      renamed2.push(Object.freeze({
-        source: typeof key === "string" ? key : base,
-        identifier
-      }));
-    }
-    used.add(identifier);
-    identifiers.set(key, identifier);
-  }
-  return {
-    // The fallback runs the *same* rules the resolver would have, rather
-    // than a bare camelCase: an unregistered wire name otherwise came back
-    // as `class` or `options`, names the resolver never assigns.
-    // Uniquified against everything already assigned, not just the reserved
-    // words: an unregistered wire name that camelCases onto an identifier
-    // this operation already bound would otherwise alias it — compiling
-    // fine and sending the wrong value. Only reachable for operations built
-    // outside the normalizer, but the resolver is public API.
-    of: /* @__PURE__ */ __name((wireName) => identifiers.get(wireName) ?? deriveLocalName(camelCase(wireName), [
-      ...used
-    ]), "of"),
-    body: identifiers.get(REQUEST_BODY_KEY),
-    all: Object.freeze([
-      ...identifiers.values()
-    ]),
-    renamed: Object.freeze(renamed2),
-    merged: Object.freeze([
-      ...merged
-    ])
-  };
-}
-__name(computeArgumentNames, "computeArgumentNames");
-function jsonBodyIdentifier(operation, config) {
-  if (!operation.requestBody || operation.isMultipart) {
-    return void 0;
-  }
-  if (!operation.requestBody.content?.[CONTENT_TYPES.JSON]) {
-    return void 0;
-  }
-  const bodyType = getRequestBodyType(operation.requestBody, config);
-  return isDataTypeInterface(bodyType) ? camelCase(bodyType) : "requestBody";
-}
-__name(jsonBodyIdentifier, "jsonBodyIdentifier");
-function deriveLocalName(base, taken) {
-  const used = new Set(taken);
-  let name = base;
-  let suffix = 2;
-  while (used.has(name)) {
-    name = `${base}${suffix}`;
-    suffix++;
-  }
-  return name;
-}
-__name(deriveLocalName, "deriveLocalName");
-
 // ../../shared/src/emit/url.emit.ts
 function plainParamValue(identifier) {
   return identifier;
@@ -3521,34 +3011,24 @@ function signalAwareParamValue(identifier) {
   return `typeof ${identifier} === 'function' ? ${identifier}() : ${identifier}`;
 }
 __name(signalAwareParamValue, "signalAwareParamValue");
-function emitUrlExpression(path3, pathParams, argumentNames, paramValue = plainParamValue) {
-  const declared = new Set(pathParams.map((param) => param.name));
-  const unresolved = (path3.match(/{([^{}]*)}/g) ?? []).map((placeholder) => placeholder.slice(1, -1)).filter((name) => !declared.has(name));
-  if (unresolved.length > 0) {
-    throw new UnresolvedPathTemplateError(`Path "${path3}" declares no parameter for ${unresolved.map((name) => `{${name}}`).join(", ")}. Declare each placeholder as a path parameter, or remove it from the path.`, path3, unresolved);
-  }
-  let urlExpression = "`${this.basePath}" + escapeTemplateLiteral(path3) + "`";
+function emitUrlExpression(path3, pathParams, paramValue = plainParamValue) {
+  let urlExpression = `\`\${this.basePath}${path3}\``;
   pathParams.forEach((param) => {
-    const replacement = "${" + paramValue(argumentNames.of(param.name)) + "}";
-    urlExpression = urlExpression.split(`{${escapeTemplateLiteral(param.name)}}`).join(replacement);
+    urlExpression = urlExpression.replace(`{${param.name}}`, `\${${paramValue(camelCase(param.name))}}`);
   });
   return urlExpression;
 }
 __name(emitUrlExpression, "emitUrlExpression");
 
 // ../../shared/src/emit/query-params.emit.ts
-function emitSignalAwareQueryParams(queryParams, argumentNames) {
+function emitSignalAwareQueryParams(queryParams) {
   if (queryParams.length === 0) {
     return "";
   }
-  const paramMappings = queryParams.map((param) => {
-    const identifier = argumentNames.of(param.name);
-    const local = deriveLocalName(`${identifier}Value`, argumentNames.all);
-    return `const ${local} = ${signalAwareParamValue(identifier)};
-                if (${local} != null) {
-                    params = HttpParamsBuilder.addToHttpParams(params, ${local}, ${quoteLiteral(param.name)});
-                }`;
-  }).join("\n");
+  const paramMappings = queryParams.map((param) => `const ${camelCase(param.name)}Value = ${signalAwareParamValue(camelCase(param.name))};
+                if (${camelCase(param.name)}Value != null) {
+                    params = HttpParamsBuilder.addToHttpParams(params, ${camelCase(param.name)}Value, '${param.name}');
+                }`).join("\n");
   return `
 let params = new HttpParams();
 ${paramMappings}`;
@@ -3595,149 +3075,22 @@ function listGeneratedFileNames(project, directoryPath, suffix) {
 __name(listGeneratedFileNames, "listGeneratedFileNames");
 
 // ../../shared/src/utils/functions/token-names.ts
-function effectiveClientName(clientName) {
-  return clientName ? clientName : "default";
-}
-__name(effectiveClientName, "effectiveClientName");
-function tokenSuffix(clientName) {
-  return effectiveClientName(clientName).toUpperCase().replace(/[^A-Z0-9]/g, "_");
-}
-__name(tokenSuffix, "tokenSuffix");
-function getClientContextTokenName(clientName) {
-  const clientSuffix = tokenSuffix(clientName);
+function getClientContextTokenName(clientName = "default") {
+  const clientSuffix = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
   return `CLIENT_CONTEXT_TOKEN_${clientSuffix}`;
 }
 __name(getClientContextTokenName, "getClientContextTokenName");
-function getBasePathTokenName(clientName) {
-  const clientSuffix = tokenSuffix(clientName);
+function getBasePathTokenName(clientName = "default") {
+  const clientSuffix = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
   return `BASE_PATH_${clientSuffix}`;
 }
 __name(getBasePathTokenName, "getBasePathTokenName");
 
-// ../../shared/src/utils/functions/controller-groups.ts
-function groupOperationsByController(operations, onWarning) {
-  const groups = {};
-  const controllerByFold = /* @__PURE__ */ new Map();
-  const tagSpellings = /* @__PURE__ */ new Map();
-  const namelessTags = /* @__PURE__ */ new Set();
-  operations.forEach((operation) => {
-    const tag = operation.tags?.[0];
-    let rawName = "Default";
-    if (tag !== void 0) {
-      rawName = tag;
-    } else {
-      const pathParts = operation.path.split("/").filter((part) => part && !part.startsWith("{"));
-      if (pathParts.length > 1) {
-        rawName = pathParts[1];
-      }
-    }
-    const sanitized = pascalCase(rawName);
-    const isNameless = !/\p{L}/u.test(sanitized);
-    const candidate = isNameless ? "Default" : sanitized;
-    const fold = candidate.toLowerCase();
-    const controllerName = controllerByFold.get(fold) ?? candidate;
-    controllerByFold.set(fold, controllerName);
-    if (tag !== void 0 && isNameless) {
-      namelessTags.add(tag);
-    } else if (tag !== void 0) {
-      const spellings = tagSpellings.get(controllerName) ?? /* @__PURE__ */ new Set();
-      spellings.add(tag);
-      tagSpellings.set(controllerName, spellings);
-    }
-    if (!groups[controllerName]) {
-      groups[controllerName] = [];
-    }
-    groups[controllerName].push(operation);
-  });
-  for (const tag of namelessTags) {
-    onWarning?.(`Tag "${tag}" contains no characters usable in a name \u2014 its operations are generated into the "Default" controller. Rename the tag to give them a file of their own.`);
-  }
-  for (const [controllerName, spellings] of tagSpellings) {
-    if (spellings.size > 1) {
-      onWarning?.(`Tags ${[
-        ...spellings
-      ].map((name) => `"${name}"`).join(" and ")} all map to the controller "${controllerName}" \u2014 their operations are generated into one file. Rename one tag to keep them apart.`);
-    }
-  }
-  return groups;
-}
-__name(groupOperationsByController, "groupOperationsByController");
-
-// ../../shared/src/utils/functions/method-names.ts
-var RESERVED_MEMBER_NAMES = Object.freeze([
-  "constructor",
-  "httpClient",
-  "basePath",
-  "clientContextToken",
-  "createContextWithClientId"
-]);
-var RESERVED_MEMBER_SET = new Set(RESERVED_MEMBER_NAMES);
-function reservedMemberCollision(operation, config) {
-  if (config.options.customizeMethodName || !operation.operationId) {
-    return void 0;
-  }
-  const natural = camelCase(operation.operationId);
-  return RESERVED_MEMBER_SET.has(natural) ? {
-    from: natural,
-    to: `_${natural}`
-  } : void 0;
+// ../../shared/src/utils/functions/duplicate-function-name.ts
+function hasDuplicateFunctionNames(arr) {
+  return new Set(arr.map((fn) => fn.getName())).size !== arr.length;
 }
-__name(reservedMemberCollision, "reservedMemberCollision");
-function getOperationMethodName(operation, config) {
-  const customize = config.options.customizeMethodName;
-  if (!customize) {
-    return defaultOperationMethodName(operation);
-  }
-  if (operation.operationId == null) {
-    throw new InvalidIdentifierError(`customizeMethodName needs an operationId, and ${describeOperation(operation)} has none. Add one to the spec, or drop customizeMethodName to use the derived name.`, operation);
-  }
-  const customName = customize(operation.operationId);
-  if (!isValidIdentifier(customName) || RESERVED_MEMBER_SET.has(customName)) {
-    throw new InvalidIdentifierError(`customizeMethodName returned "${customName}" for ${describeOperation(operation)}, which is not a usable TypeScript method name. Return an identifier \u2014 letters, digits, "_" and "$", not starting with a digit \u2014 and not one of ${RESERVED_MEMBER_NAMES.map((name) => `"${name}"`).join(", ")}.`, operation, customName);
-  }
-  return customName;
-}
-__name(getOperationMethodName, "getOperationMethodName");
-function defaultOperationMethodName(operation) {
-  if (operation.operationId) {
-    const name = camelCase(operation.operationId);
-    return RESERVED_MEMBER_SET.has(name) ? `_${name}` : name;
-  }
-  const method = pascalCase(operation.method.toLowerCase());
-  const pathParts = operation.path.split("/").filter((segment) => segment !== "").map((segment) => pascalCase(segment));
-  const resource = pathParts.join("") || "resource";
-  return `${camelCase(resource)}${method}`;
-}
-__name(defaultOperationMethodName, "defaultOperationMethodName");
-
-// ../../shared/src/utils/functions/distinct-member-names.ts
-function assertDistinctMemberNames(serviceClass, className, operations, methodNameOf) {
-  const methodNames = serviceClass.getMethods().map((method) => method.getName());
-  const propertyNames = new Set(serviceClass.getProperties().map((property) => property.getName()));
-  const duplicates = [
-    ...new Set(methodNames.filter((name, index) => methodNames.indexOf(name) !== index || propertyNames.has(name)))
-  ];
-  if (duplicates.length === 0) {
-    return;
-  }
-  const byName = new Map(duplicates.map((name) => [
-    name,
-    []
-  ]));
-  for (const operation of operations) {
-    byName.get(methodNameOf(operation))?.push(operation);
-  }
-  const detail = [
-    ...byName
-  ].map(([name, ops]) => {
-    const from = ops.map(describeOperation).join(" and ");
-    return propertyNames.has(name) ? `"${name}" from ${from} (a property of ${className})` : `"${name}" from ${from}`;
-  }).join("; ");
-  throw new DuplicateGeneratedNameError(`Operations map to the same member name in ${className}: ${detail}. Ensure each operationId maps to a unique name.`, duplicates, [
-    ...byName.values()
-  ].flat());
-}
-__name(assertDistinctMemberNames, "assertDistinctMemberNames");
+__name(hasDuplicateFunctionNames, "hasDuplicateFunctionNames");
 
 // ../../shared/src/config/constants.ts
 var disableLinting = `// @ts-nocheck
@@ -3790,14 +3143,6 @@ var HttpResourceMethodBodyGenerator = class {
   constructor(config) {
     this.config = config;
   }
-  /**
-   * The plugin reserves its own bindings (`resourceOptions`/`requestOptions`),
-   * not the core service's — resolving against the wrong set would let a
-   * `requestOptions` query parameter capture the plugin's own parameter.
-   */
-  argumentNames(operation) {
-    return resolveArgumentNames(operation, this.config, RESOURCE_ARGUMENT_PROFILE);
-  }
   generateMethodBody(operation) {
     const bodyParts = [
       this.generateDefaultHeaders(operation),
@@ -3829,7 +3174,7 @@ var HttpResourceMethodBodyGenerator = class {
   }
   generateRequestOptions(operation) {
     const entries = [];
-    const url = emitUrlExpression(operation.path, operation.pathParams, this.argumentNames(operation), signalAwareParamValue);
+    const url = emitUrlExpression(operation.path, operation.pathParams, signalAwareParamValue);
     entries.push(`url: ${url}`);
     entries.push(`method: "GET"`);
     entries.push("...requestOptions");
@@ -3847,7 +3192,7 @@ var HttpResourceMethodBodyGenerator = class {
   }
   generateHttpResource(operation) {
     const resourceOptions = this.generateRequestOptions(operation);
-    const queryParams = emitSignalAwareQueryParams(operation.queryParams, this.argumentNames(operation));
+    const queryParams = emitSignalAwareQueryParams(operation.queryParams);
     let httpResource = "httpResource";
     switch (operation.responseType) {
       case "blob":
@@ -3895,14 +3240,13 @@ var HttpResourceMethodParamsGenerator = class {
   }
   generateApiParameters(operation) {
     const params = [];
-    const argumentNames = resolveArgumentNames(operation, this.config, RESOURCE_ARGUMENT_PROFILE);
     operation.pathParams.forEach((param) => {
       const paramType = getTypeScriptType(param.schema || {
         ...param
       }, this.config);
       const signalParamType = param.required ? `Signal<${paramType}>` : `Signal<${paramType} | undefined>`;
       params.push({
-        name: argumentNames.of(param.name),
+        name: camelCase(param.name),
         type: `${signalParamType} | ${paramType}`,
         hasQuestionToken: !param.required
       });
@@ -3913,7 +3257,7 @@ var HttpResourceMethodParamsGenerator = class {
       }, this.config);
       const signalParamType = param.required ? `Signal<${paramType}>` : `Signal<${paramType} | undefined>`;
       params.push({
-        name: argumentNames.of(param.name),
+        name: camelCase(param.name),
         type: `${signalParamType} | ${paramType}`,
         hasQuestionToken: !param.required
       });
@@ -3984,11 +3328,31 @@ var HttpResourceMethodGenerator = class {
       returnType,
       statements: methodBody,
       overloads,
-      docs: emitDocs(operation.description)
+      docs: operation.description ? [
+        operation.description
+      ] : void 0
     });
   }
   generateMethodName(operation) {
-    return getOperationMethodName(operation, this.config);
+    if (this.config.options.customizeMethodName) {
+      if (operation.operationId == null) {
+        throw new Error(`Operation ID is required for method name customization of operation: (${operation.method}) ${operation.path}`);
+      }
+      return this.config.options.customizeMethodName(operation.operationId);
+    } else {
+      return this.defaultNameGenerator(operation);
+    }
+  }
+  defaultNameGenerator(operation) {
+    if (operation.operationId) {
+      return camelCase(operation.operationId);
+    }
+    const method = pascalCase(operation.method.toLowerCase());
+    const pathParts = operation.path.split("/").map((str2) => {
+      return pascalCase(pascalCase(str2).replace(/[^a-zA-Z0-9]/g, ""));
+    });
+    const resource = pathParts.join("") || "resource";
+    return `${camelCase(resource)}${method}`;
   }
   generateReturnType(operation) {
     const response = operation.responses?.["200"] || operation.responses?.["201"] || operation.responses?.["204"];
@@ -4063,6 +3427,7 @@ var HttpResourceIndexGenerator = class {
       });
     });
     sourceFile.formatText();
+    sourceFile.saveSync();
   }
 };
 
@@ -4092,15 +3457,32 @@ var HttpResourceGenerator = class {
       this.onWarning?.("No API paths found in the specification");
       return;
     }
-    const controllerGroups = groupOperationsByController(paths, this.onWarning);
-    await Promise.all(
-      // Must return the promise: without it Promise.all awaits [undefined],
-      // and a generateServiceFile rejection escapes as an unhandled
-      // rejection while generation reports success.
-      Object.entries(controllerGroups).map(([controllerName, operations]) => this.generateServiceFile(controllerName, operations, outputDir))
-    );
+    const controllerGroups = this.groupPathsByController(paths);
+    await Promise.all(Object.entries(controllerGroups).map(([controllerName, operations]) => {
+      this.generateServiceFile(controllerName, operations, outputDir);
+    }));
     this.indexGenerator.generateIndex(outputRoot);
   }
+  groupPathsByController(paths) {
+    const groups = {};
+    paths.forEach((path3) => {
+      let controllerName = "Default";
+      if (path3.tags && path3.tags.length > 0) {
+        controllerName = path3.tags[0];
+      } else {
+        const pathParts = path3.path.split("/").filter((p) => p && !p.startsWith("{"));
+        if (pathParts.length > 1) {
+          controllerName = pascalCase(pathParts[1]);
+        }
+      }
+      controllerName = pascalCase(controllerName);
+      if (!groups[controllerName]) {
+        groups[controllerName] = [];
+      }
+      groups[controllerName].push(path3);
+    });
+    return groups;
+  }
   async generateServiceFile(controllerName, operations, outputDir) {
     const fileName = `${camelCase(controllerName)}.resource.ts`;
     const filePath = path2.join(outputDir, fileName);
@@ -4110,6 +3492,7 @@ var HttpResourceGenerator = class {
     this.addServiceClass(sourceFile, controllerName, operations);
     sourceFile.fixMissingImports().formatText();
     sourceFile.insertText(0, HTTP_RESOURCE_GENERATOR_HEADER_COMMENT(getResourceClassName(controllerName, this.config.options.naming?.resources)));
+    sourceFile.saveSync();
   }
   addServiceClass(sourceFile, controllerName, operations) {
     const className = getResourceClassName(controllerName, this.config.options.naming?.resources);
@@ -4185,23 +3568,14 @@ var HttpResourceGenerator = class {
       ],
       returnType: "HttpContext",
       statements: `const context = existingContext || new HttpContext();
-return context.set(this.clientContextToken, ${quoteLiteral(effectiveClientName(this.config.clientName))});`
+return context.set(this.clientContextToken, '${this.config.clientName || "default"}');`
     });
     operations.forEach((operation) => {
-      const { renamed: renamed2, merged } = resolveArgumentNames(operation, this.config, RESOURCE_ARGUMENT_PROFILE);
-      for (const { source, identifier } of renamed2) {
-        this.onWarning?.(`Parameter "${source}" of ${describeOperation(operation)} is exposed as "${identifier}" \u2014 its natural name is already taken by another parameter or by the resource method itself.`);
-      }
-      for (const wireName of merged) {
-        this.onWarning?.(`Parameter "${wireName}" of ${describeOperation(operation)} is declared in more than one location; they collapse into one argument, so the first declaration's type wins and the same value is sent for both.`);
-      }
-      const collision = reservedMemberCollision(operation, this.config);
-      if (collision) {
-        this.onWarning?.(`Operation ${describeOperation(operation)} would be named "${collision.from}", which the generated class already binds \u2014 it is emitted as "${collision.to}". Rename the operationId to choose the name.`);
-      }
       this.methodGenerator.addResourceMethod(serviceClass, operation);
     });
-    assertDistinctMemberNames(serviceClass, className, operations, (op) => this.methodGenerator.generateMethodName(op));
+    if (hasDuplicateFunctionNames(serviceClass.getMethods())) {
+      throw new Error(`Duplicate method names found in service class ${className}. Please ensure unique method names for each operation.`);
+    }
   }
 };
 // Annotate the CommonJS export names for ESM import in node: