@kubb/plugin-oas 3.0.0-alpha.1 → 3.0.0-alpha.10

package/dist/index.js

@@ -1,149 +1,103 @@
 import {
   parseFromConfig
-} from "./chunk-Y4V7HHX7.js";
+} from "./chunk-N7EEVJA6.js";
+import "./chunk-SQ64ESS4.js";
 import {
+  Oas,
   SchemaGenerator,
   isKeyword,
+  require_jsx_runtime,
   schemaKeywords
-} from "./chunk-K6KUETAI.js";
+} from "./chunk-M347763D.js";
 import {
-  __privateAdd,
-  __privateGet,
-  __privateMethod,
-  __privateSet,
+  __toESM,
   getSchemas,
   init_esm_shims
-} from "./chunk-UB552H4J.js";
+} from "./chunk-SZDO532A.js";
 
 // src/index.ts
 init_esm_shims();
 
-// src/plugin.ts
+// src/OperationGenerator.ts
 init_esm_shims();
-import path from "path";
-import { createPlugin } from "@kubb/core";
-import { camelCase } from "@kubb/core/transformers";
-var pluginOasName = "plugin-oas";
-var pluginOas = createPlugin((options) => {
-  const {
-    output = { path: "schemas", export: false },
-    experimentalFilter: filter,
-    experimentalSort: sort,
-    validate = true,
-    serverIndex = 0,
-    contentType,
-    oasClass
-  } = options;
-  const getOas = async ({ config, logger, formatOptions }) => {
-    try {
-      const oas = await parseFromConfig(config, formatOptions, oasClass);
-      if (validate) {
-        await oas.valdiate();
+import { BaseGenerator } from "@kubb/core";
+import transformers from "@kubb/core/transformers";
+var OperationGenerator = class extends BaseGenerator {
+  #operationsByMethod = {};
+  get operationsByMethod() {
+    return this.#operationsByMethod;
+  }
+  set operationsByMethod(paths) {
+    this.#operationsByMethod = paths;
+  }
+  #getOptions(operation, method) {
+    const { override = [] } = this.context;
+    return override.find(({ pattern, type }) => {
+      if (type === "tag") {
+        return !!operation.getTags()[0]?.name.match(pattern);
       }
-      return oas;
-    } catch (e) {
-      const error = e;
-      logger.emit("warning", error?.message);
-      return parseFromConfig(config, {}, oasClass);
-    }
-  };
-  return {
-    name: pluginOasName,
-    options,
-    api() {
-      const { config, logger } = this;
-      return {
-        getOas(formatOptions) {
-          return getOas({ config, logger, formatOptions });
-        },
-        async getSchemas({ includes } = {}) {
-          const oas = await this.getOas();
-          return getSchemas({ oas, contentType, includes });
-        },
-        async getBaseURL() {
-          const oasInstance = await this.getOas();
-          const baseURL = oasInstance.api.servers?.at(serverIndex)?.url;
-          return baseURL;
-        },
-        contentType
-      };
-    },
-    resolvePath(baseName) {
-      if (output === false) {
-        return void 0;
+      if (type === "operationId") {
+        return !!operation.getOperationId().match(pattern);
       }
-      const root = path.resolve(this.config.root, this.config.output.path);
-      return path.resolve(root, output.path, baseName);
-    },
-    resolveName(name, type) {
-      return camelCase(name, { isFile: type === "file" });
-    },
-    async writeFile(path2, source) {
-      if (!path2.endsWith(".json") || !source) {
-        return;
+      if (type === "path") {
+        return !!operation.path.match(pattern);
       }
-      return this.fileManager.write(path2, source, { sanity: false });
-    },
-    async buildStart() {
-      if (!output) {
-        return;
+      if (type === "method") {
+        return !!method.match(pattern);
       }
-      const oas = await getOas({
-        config: this.config,
-        logger: this.logger,
-        formatOptions: {
-          filterSet: filter,
-          sortSet: sort
-        }
-      });
-      await oas.dereference();
-      const schemas = getSchemas({ oas, contentType });
-      const mapSchema = async ([name, schema]) => {
-        const resolvedPath = this.resolvePath({
-          baseName: `${name}.json`,
-          pluginKey: this.plugin.key
-        });
-        const resvoledFileName = this.resolveName({
-          name: `${name}.json`,
-          pluginKey: [pluginOasName],
-          type: "file"
-        });
-        if (!resolvedPath) {
-          return;
-        }
-        await this.addFile({
-          path: resolvedPath,
-          baseName: resvoledFileName,
-          source: JSON.stringify(schema),
-          meta: {
-            pluginKey: this.plugin.key
-          }
-        });
-      };
-      const promises = Object.entries(schemas).map(mapSchema);
-      await Promise.all(promises);
-    }
-  };
-});
-
-// src/OperationGenerator.ts
-init_esm_shims();
-import { Generator } from "@kubb/core";
-import transformers from "@kubb/core/transformers";
-var _operationsByMethod, _OperationGenerator_instances, getOptions_fn, isExcluded_fn, isIncluded_fn, methods_get;
-var OperationGenerator = class extends Generator {
-  constructor() {
-    super(...arguments);
-    __privateAdd(this, _OperationGenerator_instances);
-    __privateAdd(this, _operationsByMethod, {});
+      return false;
+    })?.options || {};
   }
-  get operationsByMethod() {
-    return __privateGet(this, _operationsByMethod);
+  /**
+   *
+   * @deprecated
+   */
+  #isExcluded(operation, method) {
+    const { exclude = [] } = this.context;
+    let matched = false;
+    exclude.forEach(({ pattern, type }) => {
+      if (type === "tag" && !matched) {
+        matched = !!operation.getTags()[0]?.name.match(pattern);
+      }
+      if (type === "operationId" && !matched) {
+        matched = !!operation.getOperationId().match(pattern);
+      }
+      if (type === "path" && !matched) {
+        matched = !!operation.path.match(pattern);
+      }
+      if (type === "method" && !matched) {
+        matched = !!method.match(pattern);
+      }
+    });
+    return matched;
   }
-  set operationsByMethod(paths) {
-    __privateSet(this, _operationsByMethod, paths);
+  /**
+   *
+   * @deprecated
+   */
+  #isIncluded(operation, method) {
+    const { include = [] } = this.context;
+    let matched = false;
+    include.forEach(({ pattern, type }) => {
+      if (type === "tag" && !matched) {
+        matched = !!operation.getTags()[0]?.name.match(pattern);
+      }
+      if (type === "operationId" && !matched) {
+        matched = !!operation.getOperationId().match(pattern);
+      }
+      if (type === "path" && !matched) {
+        matched = !!operation.path.match(pattern);
+      }
+      if (type === "method" && !matched) {
+        matched = !!method.match(pattern);
+      }
+    });
+    return matched;
   }
-  getSchemas(operation, { forStatusCode, resolveName = (name) => name } = {}) {
+  getSchemas(operation, {
+    forStatusCode,
+    resolveName = (name) => name
+  } = {}) {
     const pathParamsSchema = this.context.oas.getParametersSchema(operation, "path");
     const queryParamsSchema = this.context.oas.getParametersSchema(operation, "query");
     const headerParamsSchema = this.context.oas.getParametersSchema(operation, "header");
@@ -217,16 +171,17 @@ var OperationGenerator = class extends Generator {
       statusCodes
     };
   }
-  async build() {
+  #methods = ["get", "post", "patch", "put", "delete"];
+  async build(...generators) {
     const { oas } = this.context;
     const paths = oas.getPaths();
     this.operationsByMethod = Object.entries(paths).reduce((acc, [path2, method]) => {
       const methods = Object.keys(method);
       methods.forEach((method2) => {
         const operation = oas.operation(path2, method2);
-        if (operation && __privateGet(this, _OperationGenerator_instances, methods_get)[method2]) {
-          const isExcluded = __privateMethod(this, _OperationGenerator_instances, isExcluded_fn).call(this, operation, method2);
-          const isIncluded = this.context.include ? __privateMethod(this, _OperationGenerator_instances, isIncluded_fn).call(this, operation, method2) : true;
+        if (operation && [this.#methods].some((methods2) => method2 === operation.method)) {
+          const isExcluded = this.#isExcluded(operation, method2);
+          const isIncluded = this.context.include ? this.#isIncluded(operation, method2) : true;
           if (isIncluded && !isExcluded) {
             if (!acc[path2]) {
               acc[path2] = {};
@@ -247,26 +202,53 @@ var OperationGenerator = class extends Generator {
       const methods = this.operationsByMethod[path2] ? Object.keys(this.operationsByMethod[path2]) : [];
       methods.forEach((method) => {
         const { operation } = this.operationsByMethod[path2]?.[method];
-        const options = __privateMethod(this, _OperationGenerator_instances, getOptions_fn).call(this, operation, method);
-        const promiseMethod = __privateGet(this, _OperationGenerator_instances, methods_get)[method]?.call(this, operation, {
-          ...this.options,
-          ...options
-        });
+        const options = this.#getOptions(operation, method);
+        const methodToCall = this[method];
+        if (typeof methodToCall === "function") {
+          const promiseMethod = methodToCall?.call(this, operation, {
+            ...this.options,
+            ...options
+          });
+          if (promiseMethod) {
+            acc.push(promiseMethod);
+          }
+        }
         const promiseOperation = this.operation.call(this, operation, {
           ...this.options,
           ...options
         });
-        if (promiseMethod) {
-          acc.push(promiseMethod);
-        }
         if (promiseOperation) {
           acc.push(promiseOperation);
         }
+        generators?.forEach((generator) => {
+          const promise = generator.operation?.({
+            instance: this,
+            operation,
+            options: {
+              ...this.options,
+              ...options
+            }
+          });
+          if (promise) {
+            acc.push(promise);
+          }
+        });
       });
       return acc;
     }, []);
     const operations = Object.values(this.operationsByMethod).map((item) => Object.values(item).map((item2) => item2.operation));
     promises.push(this.all(operations.flat().filter(Boolean), this.operationsByMethod));
+    generators?.forEach((generator) => {
+      const promise = generator.operations?.({
+        instance: this,
+        operations: operations.flat().filter(Boolean),
+        operationsByMethod: this.operationsByMethod,
+        options: this.options
+      });
+      if (promise) {
+        promises.push(promise);
+      }
+    });
     const files = await Promise.all(promises);
     return files.flat().filter(Boolean);
   }
@@ -274,131 +256,200 @@ var OperationGenerator = class extends Generator {
    * Operation
    */
   async operation(operation, options) {
-    return null;
+    return [];
   }
   /**
    * GET
    */
   async get(operation, options) {
-    return null;
+    return [];
   }
   /**
    * POST
    */
   async post(operation, options) {
-    return null;
+    return [];
   }
   /**
    * PATCH
    */
   async patch(operation, options) {
-    return null;
+    return [];
   }
   /**
    * PUT
    */
   async put(operation, options) {
-    return null;
+    return [];
   }
   /**
    * DELETE
    */
   async delete(operation, options) {
-    return null;
+    return [];
   }
   /**
    * Combination of GET, POST, PATCH, PUT, DELETE
    */
   async all(operations, paths) {
-    return null;
+    return [];
   }
 };
-_operationsByMethod = new WeakMap();
-_OperationGenerator_instances = new WeakSet();
-getOptions_fn = function(operation, method) {
-  const { override = [] } = this.context;
-  return override.find(({ pattern, type }) => {
-    if (type === "tag") {
-      return !!operation.getTags()[0]?.name.match(pattern);
-    }
-    if (type === "operationId") {
-      return !!operation.getOperationId().match(pattern);
-    }
-    if (type === "path") {
-      return !!operation.path.match(pattern);
-    }
-    if (type === "method") {
-      return !!method.match(pattern);
-    }
-    return false;
-  })?.options || {};
-};
-/**
- *
- * @deprecated
- */
-isExcluded_fn = function(operation, method) {
-  const { exclude = [] } = this.context;
-  let matched = false;
-  exclude.forEach(({ pattern, type }) => {
-    if (type === "tag" && !matched) {
-      matched = !!operation.getTags()[0]?.name.match(pattern);
-    }
-    if (type === "operationId" && !matched) {
-      matched = !!operation.getOperationId().match(pattern);
-    }
-    if (type === "path" && !matched) {
-      matched = !!operation.path.match(pattern);
-    }
-    if (type === "method" && !matched) {
-      matched = !!method.match(pattern);
-    }
-  });
-  return matched;
-};
-/**
- *
- * @deprecated
- */
-isIncluded_fn = function(operation, method) {
-  const { include = [] } = this.context;
-  let matched = false;
-  include.forEach(({ pattern, type }) => {
-    if (type === "tag" && !matched) {
-      matched = !!operation.getTags()[0]?.name.match(pattern);
-    }
-    if (type === "operationId" && !matched) {
-      matched = !!operation.getOperationId().match(pattern);
-    }
-    if (type === "path" && !matched) {
-      matched = !!operation.path.match(pattern);
-    }
-    if (type === "method" && !matched) {
-      matched = !!method.match(pattern);
+
+// src/plugin.ts
+init_esm_shims();
+import path from "node:path";
+import { createPlugin } from "@kubb/core";
+import { camelCase } from "@kubb/core/transformers";
+var pluginOasName = "plugin-oas";
+var pluginOas = createPlugin((options) => {
+  const {
+    output = { path: "schemas", export: false },
+    experimentalFilter: filter,
+    experimentalSort: sort,
+    validate = true,
+    serverIndex = 0,
+    contentType,
+    oasClass
+  } = options;
+  const getOas = async ({ config, logger, formatOptions }) => {
+    try {
+      const oas = await parseFromConfig(config, formatOptions, oasClass);
+      if (validate) {
+        await oas.valdiate();
+      }
+      return oas;
+    } catch (e) {
+      const error = e;
+      logger.emit("warning", error?.message);
+      return parseFromConfig(config, {}, oasClass);
     }
-  });
-  return matched;
-};
-methods_get = function() {
+  };
   return {
-    get: this.get,
-    post: this.post,
-    patch: this.patch,
-    put: this.put,
-    delete: this.delete,
-    head: void 0,
-    options: void 0,
-    trace: void 0
+    name: pluginOasName,
+    output: output === false ? {
+      path: "",
+      exportType: false
+    } : {
+      exportType: "barrelNamed",
+      ...output
+    },
+    options,
+    context() {
+      const { config, logger } = this;
+      return {
+        getOas(formatOptions) {
+          return getOas({ config, logger, formatOptions });
+        },
+        async getSchemas({ includes } = {}) {
+          const oas = await this.getOas();
+          return getSchemas({ oas, contentType, includes });
+        },
+        async getBaseURL() {
+          const oasInstance = await this.getOas();
+          const baseURL = oasInstance.api.servers?.at(serverIndex)?.url;
+          return baseURL;
+        },
+        contentType
+      };
+    },
+    async buildStart() {
+      if (!output) {
+        return;
+      }
+      const oas = await getOas({
+        config: this.config,
+        logger: this.logger,
+        formatOptions: {
+          filterSet: filter,
+          sortSet: sort
+        }
+      });
+      await oas.dereference();
+      const root = path.resolve(this.config.root, this.config.output.path);
+      const schemas = getSchemas({ oas, contentType });
+      const mapSchema = async ([name, schema]) => {
+        const baseName = `${camelCase(name)}.json`;
+        const resolvedPath = path.resolve(root, output.path, baseName);
+        await this.addFile({
+          path: resolvedPath,
+          baseName,
+          meta: {
+            pluginKey: this.plugin.key
+          },
+          sources: [
+            {
+              name: camelCase(name),
+              isExportable: false,
+              isIndexable: false,
+              value: JSON.stringify(schema)
+            }
+          ]
+        });
+      };
+      const promises = Object.entries(schemas).map(mapSchema);
+      await Promise.all(promises);
+    }
   };
-};
+});
 
-// src/index.ts
-var definePluginDefault = pluginOas;
-var src_default = definePluginDefault;
+// src/generator.tsx
+init_esm_shims();
+var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
+import { App, createRoot } from "@kubb/react";
+function createGenerator(parseOptions) {
+  return parseOptions;
+}
+function createReactGenerator(parseOptions) {
+  return {
+    ...parseOptions,
+    async operations({ instance, options, operations, operationsByMethod }) {
+      if (!parseOptions.Operations) {
+        return [];
+      }
+      const { pluginManager, oas, plugin, mode } = instance.context;
+      const root = createRoot({
+        logger: pluginManager.logger
+      });
+      root.render(
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(App, { pluginManager, plugin, mode, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Oas, { oas, operations, generator: instance, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(parseOptions.Operations, { operations, instance, operationsByMethod, options }) }) })
+      );
+      return root.files;
+    },
+    async operation({ instance, operation, options }) {
+      if (!parseOptions.Operation) {
+        return [];
+      }
+      const { pluginManager, oas, plugin, mode } = instance.context;
+      const root = createRoot({
+        logger: pluginManager.logger
+      });
+      root.render(
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(App, { pluginManager, plugin: { ...plugin, options }, mode, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Oas, { oas, operations: [operation], generator: instance, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Oas.Operation, { operation, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(parseOptions.Operation, { operation, options, instance }) }) }) })
+      );
+      return root.files;
+    },
+    async schema({ instance, schema, name, options }) {
+      if (!parseOptions.Schema) {
+        return [];
+      }
+      const { pluginManager, oas, plugin, mode } = instance.context;
+      const root = createRoot({
+        logger: pluginManager.logger
+      });
+      const tree = instance.parse({ schema, name });
+      root.render(
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(App, { pluginManager, plugin: { ...plugin, options }, mode, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Oas, { oas, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Oas.Schema, { name, value: schema, tree, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(parseOptions.Schema, { schema, options, instance, name }) }) }) })
+      );
+      return root.files;
+    }
+  };
+}
 export {
   OperationGenerator,
   SchemaGenerator,
-  src_default as default,
+  createGenerator,
+  createReactGenerator,
   isKeyword,
   pluginOas,
   pluginOasName,