@acrool/rtk-query-codegen-openapi 1.3.0 → 1.4.0-alpha.1

package/lib/index.mjs

@@ -93,7 +93,7 @@ init_esm_shims();
 // src/services/unified-code-generator.ts
 init_esm_shims();
 import path4 from "node:path";
-import ts3 from "typescript";
+import ts4 from "typescript";
 
 // src/services/openapi-service.ts
 init_esm_shims();
@@ -499,7 +499,28 @@ function renameIdentifier(node, oldName, newName) {
     })
   ]).transformed[0];
 }
-function generateComponentSchemaFile(interfaces) {
+function isStringEnumType(node) {
+  if (!ts.isUnionTypeNode(node.type)) return null;
+  const members = [];
+  for (const member of node.type.types) {
+    if (ts.isLiteralTypeNode(member) && ts.isStringLiteral(member.literal)) {
+      members.push(member.literal.text);
+    } else {
+      return null;
+    }
+  }
+  return members.length > 0 ? members : null;
+}
+function generateEnumDeclaration(name, members) {
+  const enumMembers = members.map((value) => {
+    const key = value.charAt(0).toUpperCase() + value.slice(1);
+    return `  ${key} = "${value}"`;
+  });
+  return `export enum ${name} {
+${enumMembers.join(",\n")}
+}`;
+}
+function generateComponentSchemaFile(interfaces, includeOnly) {
   const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
   const resultFile = ts.createSourceFile(
     "component-schema.ts",
@@ -513,6 +534,16 @@ function generateComponentSchemaFile(interfaces) {
   Object.entries(interfaces).forEach(([originalName, node]) => {
     const pascalCaseName = toPascalCase(originalName);
     typeNameMapping[originalName] = pascalCaseName;
+    if (includeOnly && !includeOnly.has(originalName)) {
+      return;
+    }
+    if (ts.isTypeAliasDeclaration(node)) {
+      const enumMembers = isStringEnumType(node);
+      if (enumMembers) {
+        renamedInterfaces.push(generateEnumDeclaration(pascalCaseName, enumMembers));
+        return;
+      }
+    }
     const renamedNode = renameIdentifier(node, originalName, pascalCaseName);
     const printed = printer.printNode(ts.EmitHint.Unspecified, renamedNode, resultFile);
     renamedInterfaces.push(printed);
@@ -551,7 +582,7 @@ function generateDoNotModifyFile() {
 
 // src/services/api-code-generator.ts
 init_esm_shims();
-import ts2 from "typescript";
+import ts3 from "typescript";
 
 // src/services/endpoint-info-extractor.ts
 init_esm_shims();
@@ -653,10 +684,67 @@ var EndpointInfoExtractor = class {
 
 // src/generators/types-generator.ts
 init_esm_shims();
+import ts2 from "typescript";
 var toPascalCase2 = (name) => {
   return name.charAt(0).toUpperCase() + name.slice(1);
 };
-function generateTypesFile(endpointInfos, _options, schemaInterfaces, operationDefinitions) {
+function renameIdentifier2(node, oldName, newName) {
+  return ts2.transform(node, [
+    (context) => (rootNode) => ts2.visitNode(rootNode, function visit(node2) {
+      if (ts2.isIdentifier(node2) && node2.text === oldName) {
+        return ts2.factory.createIdentifier(newName);
+      }
+      return ts2.visitEachChild(node2, visit, context);
+    })
+  ]).transformed[0];
+}
+function prefixSharedSchemaRefs(node, allSchemaNames, localSchemaNames, declarationName) {
+  const sharedNames = /* @__PURE__ */ new Set();
+  for (const name of allSchemaNames) {
+    if (!localSchemaNames.has(name)) {
+      sharedNames.add(toPascalCase2(name));
+    }
+  }
+  return ts2.transform(node, [
+    (context) => (rootNode) => ts2.visitNode(rootNode, function visit(node2) {
+      if (ts2.isTypeReferenceNode(node2) && ts2.isIdentifier(node2.typeName)) {
+        const name = node2.typeName.text;
+        if (sharedNames.has(name) && name !== declarationName) {
+          const qualifiedName = ts2.factory.createQualifiedName(
+            ts2.factory.createIdentifier("Schema"),
+            ts2.factory.createIdentifier(name)
+          );
+          return ts2.factory.createTypeReferenceNode(qualifiedName, node2.typeArguments);
+        }
+      }
+      return ts2.visitEachChild(node2, visit, context);
+    })
+  ]).transformed[0];
+}
+function isStringEnumType2(node) {
+  if (!ts2.isUnionTypeNode(node.type)) return null;
+  const members = [];
+  for (const member of node.type.types) {
+    if (ts2.isLiteralTypeNode(member) && ts2.isStringLiteral(member.literal)) {
+      members.push(member.literal.text);
+    } else {
+      return null;
+    }
+  }
+  return members.length > 0 ? members : null;
+}
+function generateEnumDeclaration2(name, members) {
+  const enumMembers = members.map((value) => {
+    const key = value.charAt(0).toUpperCase() + value.slice(1);
+    return `  ${key} = "${value}"`;
+  });
+  return `export enum ${name} {
+${enumMembers.join(",\n")}
+}`;
+}
+function generateTypesFile(endpointInfos, _options, schemaInterfaces, operationDefinitions, localSchemaOptions) {
+  const localSchemaNames = localSchemaOptions?.localSchemaNames ?? /* @__PURE__ */ new Set();
+  const localSchemaInterfaces = localSchemaOptions?.localSchemaInterfaces ?? {};
   const schemaTypeMap = {};
   if (schemaInterfaces) {
     Object.keys(schemaInterfaces).forEach((actualTypeName) => {
@@ -671,23 +759,48 @@ function generateTypesFile(endpointInfos, _options, schemaInterfaces, operationD
       }
     });
   }
+  const hasSharedSchemaTypes = schemaInterfaces && Object.keys(schemaInterfaces).some(
+    (name) => !localSchemaNames.has(name)
+  );
   let importStatement = `/* eslint-disable */
-// [Warning] Generated automatically - do not edit manually 
-  
+// [Warning] Generated automatically - do not edit manually
+
 `;
-  const hasSchemaTypes = schemaInterfaces && Object.keys(schemaInterfaces).length > 0;
-  if (hasSchemaTypes) {
+  if (hasSharedSchemaTypes) {
     importStatement += `import * as Schema from "../schema";
 `;
   }
   importStatement += "\n";
   const typeDefinitions = [];
+  if (Object.keys(localSchemaInterfaces).length > 0) {
+    const printer = ts2.createPrinter({ newLine: ts2.NewLineKind.LineFeed });
+    const resultFile = ts2.createSourceFile("types.ts", "", ts2.ScriptTarget.Latest, false, ts2.ScriptKind.TS);
+    const localTypeDefs = [];
+    const allSchemaNameSet = new Set(schemaInterfaces ? Object.keys(schemaInterfaces) : []);
+    for (const [originalName, node] of Object.entries(localSchemaInterfaces)) {
+      const pascalCaseName = toPascalCase2(originalName);
+      if (ts2.isTypeAliasDeclaration(node)) {
+        const enumMembers = isStringEnumType2(node);
+        if (enumMembers) {
+          localTypeDefs.push(generateEnumDeclaration2(pascalCaseName, enumMembers));
+          continue;
+        }
+      }
+      let transformedNode = renameIdentifier2(node, originalName, pascalCaseName);
+      transformedNode = prefixSharedSchemaRefs(transformedNode, allSchemaNameSet, localSchemaNames, pascalCaseName);
+      const printed = printer.printNode(ts2.EmitHint.Unspecified, transformedNode, resultFile);
+      localTypeDefs.push(printed);
+    }
+    if (localTypeDefs.length > 0) {
+      typeDefinitions.push(localTypeDefs.join("\n"));
+    }
+  }
   const endpointTypes = [];
   endpointInfos.forEach((endpoint) => {
     const reqTypeName = endpoint.argTypeName;
     const resTypeName = endpoint.responseTypeName;
     if (reqTypeName) {
-      const requestTypeContent = generateRequestTypeContent(endpoint, operationDefinitions, schemaTypeMap);
+      const requestTypeContent = generateRequestTypeContent(endpoint, operationDefinitions, schemaTypeMap, localSchemaNames);
       if (requestTypeContent.trim() === "") {
         endpointTypes.push(
           `export type ${reqTypeName} = void;`,
@@ -703,7 +816,7 @@ function generateTypesFile(endpointInfos, _options, schemaInterfaces, operationD
       }
     }
     if (resTypeName) {
-      const responseTypeResult = generateResponseTypeContent(endpoint, operationDefinitions, schemaTypeMap);
+      const responseTypeResult = generateResponseTypeContent(endpoint, operationDefinitions, schemaTypeMap, localSchemaNames);
       if (responseTypeResult.content.trim() === "") {
         endpointTypes.push(
           `export type ${resTypeName} = void;`,
@@ -736,19 +849,19 @@ function generateTypesFile(endpointInfos, _options, schemaInterfaces, operationD
   }
   return importStatement + typeDefinitions.join("\n\n");
 }
-function generateRequestTypeContent(endpoint, operationDefinitions, schemaTypeMap = {}) {
+function generateRequestTypeContent(endpoint, operationDefinitions, schemaTypeMap = {}, localSchemaNames = /* @__PURE__ */ new Set()) {
   const properties = [];
   if (endpoint.queryParams && endpoint.queryParams.length > 0) {
     endpoint.queryParams.forEach((param) => {
       const optional = param.required ? "" : "?";
-      const paramType = getTypeFromParameter(param, schemaTypeMap);
+      const paramType = getTypeFromParameter(param, schemaTypeMap, localSchemaNames);
       properties.push(`  ${param.name}${optional}: ${paramType};`);
     });
   }
   if (endpoint.pathParams && endpoint.pathParams.length > 0) {
     endpoint.pathParams.forEach((param) => {
       const optional = param.required ? "" : "?";
-      const paramType = getTypeFromParameter(param, schemaTypeMap);
+      const paramType = getTypeFromParameter(param, schemaTypeMap, localSchemaNames);
       properties.push(`  ${param.name}${optional}: ${paramType};`);
     });
   }
@@ -762,15 +875,15 @@ function generateRequestTypeContent(endpoint, operationDefinitions, schemaTypeMa
     const jsonContent = content["application/json"] || content["*/*"];
     const formContent = content["multipart/form-data"] || content["application/x-www-form-urlencoded"];
     if (jsonContent?.schema) {
-      const bodyType = getTypeFromSchema(jsonContent.schema, schemaTypeMap, 1);
+      const bodyType = getTypeFromSchema(jsonContent.schema, schemaTypeMap, 1, localSchemaNames);
       properties.push(`  body: ${bodyType};`);
     } else if (formContent?.schema) {
-      const bodyType = getTypeFromSchema(formContent.schema, schemaTypeMap, 1);
+      const bodyType = getTypeFromSchema(formContent.schema, schemaTypeMap, 1, localSchemaNames);
       properties.push(`  body: ${bodyType};`);
     } else {
       const firstContent = Object.values(content)[0];
       if (firstContent?.schema) {
-        const bodyType = getTypeFromSchema(firstContent.schema, schemaTypeMap, 1);
+        const bodyType = getTypeFromSchema(firstContent.schema, schemaTypeMap, 1, localSchemaNames);
         properties.push(`  body: ${bodyType};`);
       } else {
         properties.push(`  body?: any; // Request body from OpenAPI`);
@@ -782,7 +895,7 @@ function generateRequestTypeContent(endpoint, operationDefinitions, schemaTypeMa
   }
   return properties.join("\n");
 }
-function generateResponseTypeContent(endpoint, operationDefinitions, schemaTypeMap = {}) {
+function generateResponseTypeContent(endpoint, operationDefinitions, schemaTypeMap = {}, localSchemaNames = /* @__PURE__ */ new Set()) {
   const operationDef = operationDefinitions?.find((op) => {
     return op.operation?.operationId === endpoint.operationName || op.operation?.operationId === endpoint.operationName.toLowerCase() || // 也嘗試匹配 verb + path 組合
     op.verb === endpoint.verb.toLowerCase() && op.path === endpoint.path;
@@ -794,12 +907,12 @@ function generateResponseTypeContent(endpoint, operationDefinitions, schemaTypeM
       if (jsonContent?.schema) {
         const schema = jsonContent.schema;
         if (schema.$ref || schema.type !== "object" || !schema.properties) {
-          const directType = getTypeFromSchema(schema, schemaTypeMap, 0);
+          const directType = getTypeFromSchema(schema, schemaTypeMap, 0, localSchemaNames);
           if (directType && directType !== "any") {
             return { content: directType, isDirectType: true };
           }
         }
-        const responseProps = parseSchemaProperties(schema, schemaTypeMap);
+        const responseProps = parseSchemaProperties(schema, schemaTypeMap, localSchemaNames);
         if (responseProps.length > 0) {
           return { content: responseProps.join("\n"), isDirectType: false };
         }
@@ -808,14 +921,14 @@ function generateResponseTypeContent(endpoint, operationDefinitions, schemaTypeM
   }
   return { content: "", isDirectType: false };
 }
-function parseSchemaProperties(schema, schemaTypeMap = {}) {
+function parseSchemaProperties(schema, schemaTypeMap = {}, localSchemaNames = /* @__PURE__ */ new Set()) {
   const properties = [];
   if (schema.type === "object" && schema.properties) {
     const required = schema.required || [];
     Object.entries(schema.properties).forEach(([propName, propSchema]) => {
       const isRequired = required.includes(propName);
       const optional = isRequired ? "" : "?";
-      const propType = getTypeFromSchema(propSchema, schemaTypeMap, 1);
+      const propType = getTypeFromSchema(propSchema, schemaTypeMap, 1, localSchemaNames);
       const needsQuotes = /[^a-zA-Z0-9_$]/.test(propName);
       const quotedPropName = needsQuotes ? `"${propName}"` : propName;
       if (propSchema.description) {
@@ -826,7 +939,7 @@ function parseSchemaProperties(schema, schemaTypeMap = {}) {
   }
   return properties;
 }
-function getTypeFromSchema(schema, schemaTypeMap = {}, indentLevel = 0) {
+function getTypeFromSchema(schema, schemaTypeMap = {}, indentLevel = 0, localSchemaNames = /* @__PURE__ */ new Set()) {
   if (!schema) return "any";
   if (schema.$ref) {
     const refPath = schema.$ref;
@@ -834,7 +947,7 @@ function getTypeFromSchema(schema, schemaTypeMap = {}, indentLevel = 0) {
       const originalTypeName = refPath.replace("#/components/schemas/", "");
       const actualTypeName = schemaTypeMap[originalTypeName] || originalTypeName;
       const pascalCaseTypeName = toPascalCase2(actualTypeName);
-      const baseType2 = `Schema.${pascalCaseTypeName}`;
+      const baseType2 = localSchemaNames.has(originalTypeName) ? pascalCaseTypeName : `Schema.${pascalCaseTypeName}`;
       return schema.nullable ? `${baseType2} | null` : baseType2;
     }
   }
@@ -857,7 +970,7 @@ function getTypeFromSchema(schema, schemaTypeMap = {}, indentLevel = 0) {
       baseType = "boolean";
       break;
     case "array":
-      const itemType = schema.items ? getTypeFromSchema(schema.items, schemaTypeMap, indentLevel) : "any";
+      const itemType = schema.items ? getTypeFromSchema(schema.items, schemaTypeMap, indentLevel, localSchemaNames) : "any";
       const needsParentheses = itemType.includes("|");
       baseType = needsParentheses ? `(${itemType})[]` : `${itemType}[]`;
       break;
@@ -866,7 +979,7 @@ function getTypeFromSchema(schema, schemaTypeMap = {}, indentLevel = 0) {
         const entries = Object.entries(schema.properties);
         if (entries.length === 0) {
           if (schema.additionalProperties) {
-            const valueType = schema.additionalProperties === true ? "any" : getTypeFromSchema(schema.additionalProperties, schemaTypeMap, indentLevel);
+            const valueType = schema.additionalProperties === true ? "any" : getTypeFromSchema(schema.additionalProperties, schemaTypeMap, indentLevel, localSchemaNames);
             baseType = `Record<string, ${valueType}>`;
           } else {
             baseType = "{}";
@@ -878,7 +991,7 @@ function getTypeFromSchema(schema, schemaTypeMap = {}, indentLevel = 0) {
           entries.forEach(([key, propSchema]) => {
             const required = schema.required || [];
             const optional = required.includes(key) ? "" : "?";
-            const type = getTypeFromSchema(propSchema, schemaTypeMap, indentLevel + 1);
+            const type = getTypeFromSchema(propSchema, schemaTypeMap, indentLevel + 1, localSchemaNames);
             const needsQuotes = /[^a-zA-Z0-9_$]/.test(key);
             const quotedKey = needsQuotes ? `"${key}"` : key;
             if (propSchema.description) {
@@ -891,7 +1004,7 @@ ${props.join("\n")}
 ${currentIndent}}`;
         }
       } else if (schema.additionalProperties) {
-        const valueType = schema.additionalProperties === true ? "any" : getTypeFromSchema(schema.additionalProperties, schemaTypeMap, indentLevel);
+        const valueType = schema.additionalProperties === true ? "any" : getTypeFromSchema(schema.additionalProperties, schemaTypeMap, indentLevel, localSchemaNames);
         baseType = `Record<string, ${valueType}>`;
       } else {
         baseType = "any";
@@ -903,9 +1016,9 @@ ${currentIndent}}`;
   }
   return schema.nullable ? `${baseType} | null` : baseType;
 }
-function getTypeFromParameter(param, schemaTypeMap = {}) {
+function getTypeFromParameter(param, schemaTypeMap = {}, localSchemaNames = /* @__PURE__ */ new Set()) {
   if (!param.schema) return "any";
-  return getTypeFromSchema(param.schema, schemaTypeMap);
+  return getTypeFromSchema(param.schema, schemaTypeMap, 0, localSchemaNames);
 }
 
 // src/generators/rtk-query-generator.ts
@@ -1102,7 +1215,7 @@ var ApiCodeGenerator = class {
     };
     const apiGen = this.parserService.getApiGenerator();
     const schemaInterfaces = apiGen.aliases.reduce((curr, alias) => {
-      if (ts2.isInterfaceDeclaration(alias) || ts2.isTypeAliasDeclaration(alias)) {
+      if (ts3.isInterfaceDeclaration(alias) || ts3.isTypeAliasDeclaration(alias)) {
         const name = alias.name.text;
         return {
           ...curr,
@@ -1186,6 +1299,150 @@ ${enumEntries}
 `;
 }
 
+// src/utils/schema-ref-analyzer.ts
+init_esm_shims();
+function collectRefsFromSchema(schema, refs) {
+  if (!schema || typeof schema !== "object") return;
+  if (schema.$ref && typeof schema.$ref === "string") {
+    const match = schema.$ref.match(/^#\/components\/schemas\/(.+)$/);
+    if (match) {
+      refs.add(match[1]);
+    }
+  }
+  if (schema.properties) {
+    for (const prop of Object.values(schema.properties)) {
+      collectRefsFromSchema(prop, refs);
+    }
+  }
+  if (schema.items) {
+    collectRefsFromSchema(schema.items, refs);
+  }
+  if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+    collectRefsFromSchema(schema.additionalProperties, refs);
+  }
+  for (const key of ["allOf", "oneOf", "anyOf"]) {
+    if (Array.isArray(schema[key])) {
+      for (const item of schema[key]) {
+        collectRefsFromSchema(item, refs);
+      }
+    }
+  }
+}
+function collectDirectRefs(operationDefs) {
+  const refs = /* @__PURE__ */ new Set();
+  for (const opDef of operationDefs) {
+    const op = opDef.operation;
+    if (op.parameters) {
+      for (const param of op.parameters) {
+        const p = param;
+        if (p.schema) {
+          collectRefsFromSchema(p.schema, refs);
+        }
+      }
+    }
+    if (op.requestBody) {
+      const rb = op.requestBody;
+      if (rb.content) {
+        for (const ct of Object.values(rb.content)) {
+          if (ct.schema) {
+            collectRefsFromSchema(ct.schema, refs);
+          }
+        }
+      }
+    }
+    if (op.responses) {
+      for (const resp of Object.values(op.responses)) {
+        const r = resp;
+        if (r.content) {
+          for (const ct of Object.values(r.content)) {
+            if (ct.schema) {
+              collectRefsFromSchema(ct.schema, refs);
+            }
+          }
+        }
+      }
+    }
+  }
+  return refs;
+}
+function resolveTransitiveDeps(directRefs, allSchemas) {
+  const resolved = /* @__PURE__ */ new Set();
+  const queue = [...directRefs];
+  while (queue.length > 0) {
+    const name = queue.pop();
+    if (resolved.has(name)) continue;
+    resolved.add(name);
+    const schema = allSchemas[name];
+    if (!schema) continue;
+    const nestedRefs = /* @__PURE__ */ new Set();
+    collectRefsFromSchema(schema, nestedRefs);
+    for (const ref of nestedRefs) {
+      if (!resolved.has(ref)) {
+        queue.push(ref);
+      }
+    }
+  }
+  return resolved;
+}
+function analyzeSchemaRefs(groupOperations, allSchemas, allSchemaNames) {
+  const groupRefs = /* @__PURE__ */ new Map();
+  for (const [groupKey, opDefs] of groupOperations) {
+    const directRefs = collectDirectRefs(opDefs);
+    const fullRefs = resolveTransitiveDeps(directRefs, allSchemas);
+    groupRefs.set(groupKey, fullRefs);
+  }
+  const refCountMap = /* @__PURE__ */ new Map();
+  for (const [groupKey, refs] of groupRefs) {
+    for (const schemaName of refs) {
+      if (!refCountMap.has(schemaName)) {
+        refCountMap.set(schemaName, /* @__PURE__ */ new Set());
+      }
+      refCountMap.get(schemaName).add(groupKey);
+    }
+  }
+  const sharedSchemas = /* @__PURE__ */ new Set();
+  const groupLocalSchemas = /* @__PURE__ */ new Map();
+  const unusedSchemas = /* @__PURE__ */ new Set();
+  for (const schemaName of allSchemaNames) {
+    const groups = refCountMap.get(schemaName);
+    if (!groups || groups.size === 0) {
+      unusedSchemas.add(schemaName);
+    } else if (groups.size === 1) {
+      const groupKey = [...groups][0];
+      if (!groupLocalSchemas.has(groupKey)) {
+        groupLocalSchemas.set(groupKey, /* @__PURE__ */ new Set());
+      }
+      groupLocalSchemas.get(groupKey).add(schemaName);
+    } else {
+      sharedSchemas.add(schemaName);
+    }
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [groupKey, localSchemas] of groupLocalSchemas) {
+      for (const schemaName of [...localSchemas]) {
+        const schema = allSchemas[schemaName];
+        if (!schema) continue;
+        const deps = /* @__PURE__ */ new Set();
+        collectRefsFromSchema(schema, deps);
+        for (const dep of deps) {
+          for (const [otherGroup, otherLocals] of groupLocalSchemas) {
+            if (otherGroup !== groupKey && otherLocals.has(dep)) {
+              sharedSchemas.add(dep);
+              sharedSchemas.add(schemaName);
+              otherLocals.delete(dep);
+              localSchemas.delete(schemaName);
+              changed = true;
+            }
+          }
+        }
+      }
+    }
+  }
+  return { sharedSchemas, groupLocalSchemas, unusedSchemas };
+}
+
 // src/services/unified-code-generator.ts
 var UnifiedCodeGenerator = class {
   _options;
@@ -1208,6 +1465,10 @@ var UnifiedCodeGenerator = class {
   };
   // 收集所有 tags
   allTags = /* @__PURE__ */ new Set();
+  // 收集每個 group 的 operation definitions（用於 schema 引用分析）
+  groupOperationDefs = /* @__PURE__ */ new Map();
+  // 收集每個 group 的生成選項（用於重新生成 types）
+  groupGenerationOptions = /* @__PURE__ */ new Map();
   constructor(options) {
     this._options = options;
   }
@@ -1217,6 +1478,7 @@ var UnifiedCodeGenerator = class {
   async generateAll() {
     await this.prepare();
     await this.generateApi();
+    this.splitSchemaByUsage();
     this.generateCommonTypesContent();
     this.generateSchemaContent();
     this.generateUtilsContent();
@@ -1243,7 +1505,7 @@ var UnifiedCodeGenerator = class {
     this.parserService.initialize();
     const apiGen = this.parserService.getApiGenerator();
     this.schemaInterfaces = apiGen.aliases.reduce((curr, alias) => {
-      if (ts3.isInterfaceDeclaration(alias) || ts3.isTypeAliasDeclaration(alias)) {
+      if (ts4.isInterfaceDeclaration(alias) || ts4.isTypeAliasDeclaration(alias)) {
         const name = alias.name.text;
         return {
           ...curr,
@@ -1283,6 +1545,55 @@ var UnifiedCodeGenerator = class {
       }
     }
   }
+  /**
+   * 分析 schema 引用，將只被單一 group 使用的 schema 移到該 group 的 types.ts
+   */
+  splitSchemaByUsage() {
+    if (!this.openApiDoc || this.groupOperationDefs.size === 0) return;
+    const rawSchemas = this.openApiDoc.components?.schemas ?? {};
+    const allSchemaNames = Object.keys(this.schemaInterfaces);
+    const analysis = analyzeSchemaRefs(
+      this.groupOperationDefs,
+      rawSchemas,
+      allSchemaNames
+    );
+    this.sharedSchemaNames = analysis.sharedSchemas;
+    for (const group of this.generatedContent.groups) {
+      const localNames = analysis.groupLocalSchemas.get(group.groupKey);
+      if (!localNames || localNames.size === 0) continue;
+      const groupOptions = this.groupGenerationOptions.get(group.groupKey);
+      if (!groupOptions || !this.parserService) continue;
+      const localSchemaInterfaces = {};
+      for (const name of localNames) {
+        if (this.schemaInterfaces[name]) {
+          localSchemaInterfaces[name] = this.schemaInterfaces[name];
+        }
+      }
+      const infoExtractor = new EndpointInfoExtractor(groupOptions);
+      const operationDefs = this.groupOperationDefs.get(group.groupKey) ?? [];
+      const endpointInfos = infoExtractor.extractEndpointInfos(operationDefs);
+      const generatorOptions = {
+        ...groupOptions,
+        apiConfiguration: groupOptions.apiConfiguration || {
+          file: "@/store/webapi",
+          importName: "WebApiConfiguration"
+        }
+      };
+      const newTypesContent = generateTypesFile(
+        endpointInfos,
+        generatorOptions,
+        this.schemaInterfaces,
+        operationDefs,
+        {
+          localSchemaInterfaces,
+          localSchemaNames: localNames
+        }
+      );
+      group.content.files.types = newTypesContent;
+    }
+  }
+  // 儲存 shared schema 名稱（只有這些會寫入 schema.ts）
+  sharedSchemaNames = null;
   /**
    * 生成 common types
    */
@@ -1290,10 +1601,13 @@ var UnifiedCodeGenerator = class {
     this.generatedContent.commonTypes = generateCommonTypesFile();
   }
   /**
-   * 生成Schema
+   * 生成Schema（只包含 shared types，排除 group-local 和未使用的 types）
    */
   async generateSchemaContent() {
-    this.generatedContent.componentSchema = generateComponentSchemaFile(this.schemaInterfaces);
+    this.generatedContent.componentSchema = generateComponentSchemaFile(
+      this.schemaInterfaces,
+      this.sharedSchemaNames ?? void 0
+    );
   }
   /**
    * 生成 DO_NOT_MODIFY.md
@@ -1401,6 +1715,9 @@ var UnifiedCodeGenerator = class {
     if (!this.openApiDoc || !this.parserService) {
       throw new Error("OpenAPI \u6587\u6A94\u672A\u521D\u59CB\u5316\uFF0C\u8ACB\u5148\u8ABF\u7528 prepare()");
     }
+    const groupOpDefs = this.parserService.getOperationDefinitions(groupOptions.filterEndpoints);
+    this.groupOperationDefs.set(groupInfo.groupKey, groupOpDefs);
+    this.groupGenerationOptions.set(groupInfo.groupKey, groupOptions);
     const apiGenerator = new ApiCodeGenerator(this.parserService, groupOptions);
     const result = await apiGenerator.generate();
     return result;
@@ -1409,11 +1726,12 @@ var UnifiedCodeGenerator = class {
    * 生成主 index.ts 檔案
    */
   generateMainIndex(generatedGroups) {
-    const exports = generatedGroups.map((groupKey) => `export * from "./${groupKey}";`).join("\n");
+    const groupExports = generatedGroups.map((groupKey) => `export * from "./${groupKey}";`).join("\n");
     return `/* eslint-disable */
 // [Warning] Generated automatically - do not edit manually
 
-${exports}
+export * from "./schema";
+${groupExports}
 `;
   }
 };