@kubb/plugin-oas 3.0.0-alpha.15 → 3.0.0-alpha.16

package/dist/{chunk-M3V3WMCW.js → chunk-CYF724QJ.js}

@@ -1,10 +1,5 @@
-import { __commonJS, init_esm_shims, __toESM, getSchemaFactory, getSchemas } from './chunk-GAPWY2CE.js';
-import { BaseGenerator } from '@kubb/core';
-import transformers, { pascalCase } from '@kubb/core/transformers';
-import { getUniqueName } from '@kubb/core/utils';
-import { isReference } from '@kubb/oas';
-import { uniqueWith, isDeepEqual, isNumber } from 'remeda';
-import { createContext, useApp, File, useFile, useContext } from '@kubb/react';
+import { __commonJS, init_esm_shims, __toESM } from './chunk-4OQEPWOG.js';
+import { createContext } from '@kubb/react';
 
 // ../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react.production.min.js
 var require_react_production_min = __commonJS({
@@ -1323,7 +1318,7 @@ var require_react_development = __commonJS({
           }
           return dispatcher;
         }
-        function useContext2(Context) {
+        function useContext(Context) {
           var dispatcher = resolveDispatcher();
           {
             if (Context._context !== void 0) {
@@ -2129,7 +2124,7 @@ var require_react_development = __commonJS({
         exports.startTransition = startTransition;
         exports.unstable_act = act;
         exports.useCallback = useCallback;
-        exports.useContext = useContext2;
+        exports.useContext = useContext;
         exports.useDebugValue = useDebugValue;
         exports.useDeferredValue = useDeferredValue;
         exports.useEffect = useEffect;
@@ -3067,10 +3062,10 @@ var require_react_jsx_runtime_development = __commonJS({
           }
         }
         var jsx4 = jsxWithValidationDynamic;
-        var jsxs2 = jsxWithValidationStatic;
+        var jsxs = jsxWithValidationStatic;
         exports.Fragment = REACT_FRAGMENT_TYPE;
         exports.jsx = jsx4;
-        exports.jsxs = jsxs2;
+        exports.jsxs = jsxs;
       })();
     }
   }
@@ -3088,692 +3083,11 @@ var require_jsx_runtime = __commonJS({
   }
 });
 
-// src/SchemaMapper.ts
+// src/components/index.ts
 init_esm_shims();
-var schemaKeywords = {
-  any: "any",
-  strict: "strict",
-  unknown: "unknown",
-  number: "number",
-  integer: "integer",
-  string: "string",
-  boolean: "boolean",
-  undefined: "undefined",
-  nullable: "nullable",
-  null: "null",
-  nullish: "nullish",
-  array: "array",
-  tuple: "tuple",
-  enum: "enum",
-  union: "union",
-  datetime: "datetime",
-  date: "date",
-  email: "email",
-  uuid: "uuid",
-  url: "url",
-  /* intersection */
-  default: "default",
-  const: "const",
-  and: "and",
-  describe: "describe",
-  min: "min",
-  max: "max",
-  optional: "optional",
-  readOnly: "readOnly",
-  // custom ones
-  object: "object",
-  ref: "ref",
-  matches: "matches",
-  firstName: "firstName",
-  lastName: "lastName",
-  password: "password",
-  phone: "phone",
-  blob: "blob",
-  deprecated: "deprecated",
-  example: "example",
-  schema: "schema",
-  catchall: "catchall",
-  time: "time",
-  name: "name"
-};
-function isKeyword(meta, keyword) {
-  return meta.keyword === keyword;
-}
 
-// src/SchemaGenerator.ts
+// src/components/Oas.tsx
 init_esm_shims();
-var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
-  // Collect the types of all referenced schemas, so we can export them later
-  refs = {};
-  // Keep track of already used type aliases
-  #usedAliasNames = {};
-  /**
-   * Creates a type node from a given schema.
-   * Delegates to getBaseTypeFromSchema internally and
-   * optionally adds a union with null.
-   */
-  parse(props) {
-    const options = this.#getOptions(props);
-    const defaultSchemas = this.#parseSchemaObject(props);
-    const schemas = options.transformers?.schema?.(props, defaultSchemas) || defaultSchemas || [];
-    return uniqueWith(schemas, isDeepEqual);
-  }
-  deepSearch(tree, keyword) {
-    return _SchemaGenerator.deepSearch(tree, keyword);
-  }
-  find(tree, keyword) {
-    return _SchemaGenerator.find(tree, keyword);
-  }
-  static deepSearch(tree, keyword) {
-    const foundItems = [];
-    tree?.forEach((schema) => {
-      if (schema.keyword === keyword) {
-        foundItems.push(schema);
-      }
-      if (schema.keyword === schemaKeywords.object) {
-        const subItem = schema;
-        Object.values(subItem.args?.properties || {}).forEach((entrySchema) => {
-          foundItems.push(..._SchemaGenerator.deepSearch(entrySchema, keyword));
-        });
-        Object.values(subItem.args?.additionalProperties || {}).forEach((entrySchema) => {
-          foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
-        });
-      }
-      if (schema.keyword === schemaKeywords.array) {
-        const subItem = schema;
-        subItem.args.items.forEach((entrySchema) => {
-          foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
-        });
-      }
-      if (schema.keyword === schemaKeywords.and) {
-        const subItem = schema;
-        subItem.args.forEach((entrySchema) => {
-          foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
-        });
-      }
-      if (schema.keyword === schemaKeywords.tuple) {
-        const subItem = schema;
-        subItem.args.items.forEach((entrySchema) => {
-          foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
-        });
-      }
-      if (schema.keyword === schemaKeywords.union) {
-        const subItem = schema;
-        subItem.args.forEach((entrySchema) => {
-          foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
-        });
-      }
-    });
-    return foundItems;
-  }
-  static findInObject(tree, keyword) {
-    let foundItem = void 0;
-    tree?.forEach((schema) => {
-      if (!foundItem && schema.keyword === keyword) {
-        foundItem = schema;
-      }
-      if (schema.keyword === schemaKeywords.object) {
-        const subItem = schema;
-        Object.values(subItem.args?.properties || {}).forEach((entrySchema) => {
-          if (!foundItem) {
-            foundItem = _SchemaGenerator.find(entrySchema, keyword);
-          }
-        });
-        Object.values(subItem.args?.additionalProperties || {}).forEach((entrySchema) => {
-          if (!foundItem) {
-            foundItem = _SchemaGenerator.find([entrySchema], keyword);
-          }
-        });
-      }
-    });
-    return foundItem;
-  }
-  static find(tree, keyword) {
-    let foundItem = void 0;
-    tree?.forEach((schema) => {
-      if (!foundItem && schema.keyword === keyword) {
-        foundItem = schema;
-      }
-      if (schema.keyword === schemaKeywords.array) {
-        const subItem = schema;
-        subItem.args.items.forEach((entrySchema) => {
-          if (!foundItem) {
-            foundItem = _SchemaGenerator.find([entrySchema], keyword);
-          }
-        });
-      }
-      if (schema.keyword === schemaKeywords.and) {
-        const subItem = schema;
-        subItem.args.forEach((entrySchema) => {
-          if (!foundItem) {
-            foundItem = _SchemaGenerator.find([entrySchema], keyword);
-          }
-        });
-      }
-      if (schema.keyword === schemaKeywords.tuple) {
-        const subItem = schema;
-        subItem.args.items.forEach((entrySchema) => {
-          if (!foundItem) {
-            foundItem = _SchemaGenerator.find([entrySchema], keyword);
-          }
-        });
-      }
-      if (schema.keyword === schemaKeywords.union) {
-        const subItem = schema;
-        subItem.args.forEach((entrySchema) => {
-          if (!foundItem) {
-            foundItem = _SchemaGenerator.find([entrySchema], keyword);
-          }
-        });
-      }
-    });
-    return foundItem;
-  }
-  #getUsedEnumNames(props) {
-    const options = this.#getOptions(props);
-    return options.usedEnumNames || {};
-  }
-  #getOptions({ name }) {
-    const { override = [] } = this.context;
-    return {
-      ...this.options,
-      ...override.find(({ pattern, type }) => {
-        if (name && type === "schemaName") {
-          return !!name.match(pattern);
-        }
-        return false;
-      })?.options || {}
-    };
-  }
-  #getUnknownReturn(props) {
-    const options = this.#getOptions(props);
-    if (options.unknownType === "any") {
-      return schemaKeywords.any;
-    }
-    return schemaKeywords.unknown;
-  }
-  /**
-   * Recursively creates a type literal with the given props.
-   */
-  #parseProperties({ schema, name }) {
-    const properties = schema?.properties || {};
-    const additionalProperties = schema?.additionalProperties;
-    const required = schema?.required;
-    const propertiesSchemas = Object.keys(properties).map((propertyName) => {
-      const validationFunctions = [];
-      const propertySchema = properties[propertyName];
-      const isRequired = Array.isArray(required) ? required?.includes(propertyName) : !!required;
-      const nullable = propertySchema.nullable ?? propertySchema["x-nullable"] ?? false;
-      validationFunctions.push(...this.parse({ schema: propertySchema, name: propertyName, parentName: name }));
-      validationFunctions.push({
-        keyword: schemaKeywords.name,
-        args: propertyName
-      });
-      if (!isRequired && nullable) {
-        validationFunctions.push({ keyword: schemaKeywords.nullish });
-      } else if (!isRequired) {
-        validationFunctions.push({ keyword: schemaKeywords.optional });
-      }
-      return {
-        [propertyName]: validationFunctions
-      };
-    }).reduce((acc, curr) => ({ ...acc, ...curr }), {});
-    let additionalPropertiesSchemas = [];
-    if (additionalProperties) {
-      additionalPropertiesSchemas = additionalProperties === true ? [{ keyword: this.#getUnknownReturn({ schema, name }) }] : this.parse({ schema: additionalProperties, parentName: name });
-    }
-    return [
-      {
-        keyword: schemaKeywords.object,
-        args: {
-          properties: propertiesSchemas,
-          additionalProperties: additionalPropertiesSchemas
-        }
-      }
-    ];
-  }
-  /**
-   * Create a type alias for the schema referenced by the given ReferenceObject
-   */
-  #getRefAlias(obj) {
-    const { $ref } = obj;
-    let ref = this.refs[$ref];
-    const originalName = getUniqueName($ref.replace(/.+\//, ""), this.#usedAliasNames);
-    const propertyName = this.context.pluginManager.resolveName({
-      name: originalName,
-      pluginKey: this.context.plugin.key,
-      type: "function"
-    });
-    if (ref) {
-      return [
-        {
-          keyword: schemaKeywords.ref,
-          args: { name: ref.propertyName, path: ref.path }
-        }
-      ];
-    }
-    const fileName = this.context.pluginManager.resolveName({
-      name: originalName,
-      pluginKey: this.context.plugin.key,
-      type: "file"
-    });
-    const file = this.context.pluginManager.getFile({
-      name: fileName,
-      pluginKey: this.context.plugin.key,
-      extName: ".ts"
-    });
-    ref = this.refs[$ref] = {
-      propertyName,
-      originalName,
-      path: file.path
-    };
-    return [
-      {
-        keyword: schemaKeywords.ref,
-        args: { name: ref.propertyName, path: ref?.path }
-      }
-    ];
-  }
-  #getParsedSchemaObject(schema) {
-    const parsedSchema = getSchemaFactory(this.context.oas)(schema);
-    return parsedSchema;
-  }
-  /**
-   * This is the very core of the OpenAPI to TS conversion - it takes a
-   * schema and returns the appropriate type.
-   */
-  #parseSchemaObject({ schema: _schema, name, parentName }) {
-    const options = this.#getOptions({ schema: _schema, name });
-    const unknownReturn = this.#getUnknownReturn({ schema: _schema, name });
-    const { schema, version } = this.#getParsedSchemaObject(_schema);
-    if (!schema) {
-      return [{ keyword: unknownReturn }];
-    }
-    const baseItems = [
-      {
-        keyword: schemaKeywords.schema,
-        args: {
-          type: schema.type,
-          format: schema.format
-        }
-      }
-    ];
-    const min = schema.minimum ?? schema.minLength ?? schema.minItems ?? void 0;
-    const max = schema.maximum ?? schema.maxLength ?? schema.maxItems ?? void 0;
-    const nullable = schema.nullable ?? schema["x-nullable"] ?? false;
-    if (schema.default !== void 0 && !Array.isArray(schema.default)) {
-      if (typeof schema.default === "string") {
-        baseItems.push({
-          keyword: schemaKeywords.default,
-          args: transformers.stringify(schema.default)
-        });
-      } else if (typeof schema.default === "boolean") {
-        baseItems.push({
-          keyword: schemaKeywords.default,
-          args: schema.default ?? false
-        });
-      } else {
-        baseItems.push({
-          keyword: schemaKeywords.default,
-          args: schema.default
-        });
-      }
-    }
-    if (schema.description) {
-      baseItems.push({
-        keyword: schemaKeywords.describe,
-        args: schema.description
-      });
-    }
-    if (schema.pattern) {
-      baseItems.unshift({
-        keyword: schemaKeywords.matches,
-        args: schema.pattern
-      });
-    }
-    if (max !== void 0) {
-      baseItems.unshift({ keyword: schemaKeywords.max, args: max });
-    }
-    if (min !== void 0) {
-      baseItems.unshift({ keyword: schemaKeywords.min, args: min });
-    }
-    if (nullable) {
-      baseItems.push({ keyword: schemaKeywords.nullable });
-    }
-    if (schema.type && Array.isArray(schema.type)) {
-      const [_schema2, nullable2] = schema.type;
-      if (nullable2 === "null") {
-        baseItems.push({ keyword: schemaKeywords.nullable });
-      }
-    }
-    if (schema.readOnly) {
-      baseItems.push({ keyword: schemaKeywords.readOnly });
-    }
-    if (isReference(schema)) {
-      return [
-        ...this.#getRefAlias(schema),
-        nullable && { keyword: schemaKeywords.nullable },
-        {
-          keyword: schemaKeywords.schema,
-          args: {
-            type: schema.type,
-            format: schema.format
-          }
-        }
-      ].filter(Boolean);
-    }
-    if (schema.oneOf) {
-      const schemaWithoutOneOf = { ...schema, oneOf: void 0 };
-      const union = {
-        keyword: schemaKeywords.union,
-        args: schema.oneOf.map((item) => {
-          return item && this.parse({ schema: item, name, parentName })[0];
-        }).filter(Boolean).filter((item) => {
-          return item && item.keyword !== unknownReturn;
-        })
-      };
-      if (schemaWithoutOneOf.properties) {
-        return [...this.parse({ schema: schemaWithoutOneOf, name, parentName }), union, ...baseItems];
-      }
-      return [union, ...baseItems];
-    }
-    if (schema.anyOf) {
-      const schemaWithoutAnyOf = { ...schema, anyOf: void 0 };
-      const union = {
-        keyword: schemaKeywords.union,
-        args: schema.anyOf.map((item) => {
-          return item && this.parse({ schema: item, name, parentName })[0];
-        }).filter(Boolean).filter((item) => {
-          return item && item.keyword !== unknownReturn;
-        }).map((item) => {
-          if (isKeyword(item, schemaKeywords.object)) {
-            return {
-              ...item,
-              args: {
-                ...item.args,
-                strict: true
-              }
-            };
-          }
-          return item;
-        })
-      };
-      if (schemaWithoutAnyOf.properties) {
-        return [...this.parse({ schema: schemaWithoutAnyOf, name, parentName }), union, ...baseItems];
-      }
-      return [union, ...baseItems];
-    }
-    if (schema.allOf) {
-      const schemaWithoutAllOf = { ...schema, allOf: void 0 };
-      const and = {
-        keyword: schemaKeywords.and,
-        args: schema.allOf.map((item) => {
-          return item && this.parse({ schema: item, name, parentName })[0];
-        }).filter(Boolean).filter((item) => {
-          return item && item.keyword !== unknownReturn;
-        })
-      };
-      if (schemaWithoutAllOf.properties) {
-        return [
-          {
-            ...and,
-            args: [...and.args || [], ...this.parse({ schema: schemaWithoutAllOf, name, parentName })]
-          },
-          ...baseItems
-        ];
-      }
-      return [and, ...baseItems];
-    }
-    if (schema.enum) {
-      const enumName = getUniqueName(pascalCase([parentName, name, options.enumSuffix].join(" ")), this.#getUsedEnumNames({ schema, name }));
-      const typeName = this.context.pluginManager.resolveName({
-        name: enumName,
-        pluginKey: this.context.plugin.key,
-        type: "type"
-      });
-      const nullableEnum = schema.enum.includes(null);
-      if (nullableEnum) {
-        baseItems.push({ keyword: schemaKeywords.nullable });
-      }
-      const filteredValues = schema.enum.filter((value) => value !== null);
-      const extensionEnums = ["x-enumNames", "x-enum-varnames"].filter((extensionKey) => extensionKey in schema).map((extensionKey) => {
-        return [
-          {
-            keyword: schemaKeywords.enum,
-            args: {
-              name,
-              typeName,
-              asConst: false,
-              items: [...new Set(schema[extensionKey])].map((name2, index) => ({
-                name: transformers.stringify(name2),
-                value: schema.enum?.[index],
-                format: isNumber(schema.enum?.[index]) ? "number" : "string"
-              }))
-            }
-          },
-          ...baseItems.filter(
-            (item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max && item.keyword !== schemaKeywords.matches
-          )
-        ];
-      });
-      if (schema.type === "number" || schema.type === "integer") {
-        const enumNames = extensionEnums[0]?.find((item) => isKeyword(item, schemaKeywords.enum));
-        return [
-          {
-            keyword: schemaKeywords.enum,
-            args: {
-              name: enumName,
-              typeName,
-              asConst: true,
-              items: enumNames?.args?.items ? [...new Set(enumNames.args.items)].map(({ name: name2, value }) => ({
-                name: name2,
-                value,
-                format: "number"
-              })) : [...new Set(filteredValues)].map((value) => {
-                return {
-                  name: value,
-                  value,
-                  format: "number"
-                };
-              })
-            }
-          },
-          ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max && item.keyword !== schemaKeywords.matches)
-        ];
-      }
-      if (extensionEnums.length > 0 && extensionEnums[0]) {
-        return extensionEnums[0];
-      }
-      return [
-        {
-          keyword: schemaKeywords.enum,
-          args: {
-            name: enumName,
-            typeName,
-            asConst: false,
-            items: [...new Set(filteredValues)].map((value) => ({
-              name: transformers.stringify(value),
-              value,
-              format: isNumber(value) ? "number" : "string"
-            }))
-          }
-        },
-        ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max && item.keyword !== schemaKeywords.matches)
-      ];
-    }
-    if ("prefixItems" in schema) {
-      const prefixItems = schema.prefixItems;
-      const min2 = schema.minimum ?? schema.minLength ?? schema.minItems ?? void 0;
-      const max2 = schema.maximum ?? schema.maxLength ?? schema.maxItems ?? void 0;
-      return [
-        {
-          keyword: schemaKeywords.tuple,
-          args: {
-            min: min2,
-            max: max2,
-            items: prefixItems.map((item) => {
-              return this.parse({ schema: item, name, parentName })[0];
-            }).filter(Boolean)
-          }
-        },
-        ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max)
-      ];
-    }
-    if (version === "3.1" && "const" in schema) {
-      if (schema["const"]) {
-        return [
-          {
-            keyword: schemaKeywords.const,
-            args: {
-              name: schema["const"],
-              format: typeof schema["const"] === "number" ? "number" : "string",
-              value: schema["const"]
-            }
-          },
-          ...baseItems
-        ];
-      }
-      return [{ keyword: schemaKeywords.null }];
-    }
-    if (schema.format) {
-      switch (schema.format) {
-        case "binary":
-          baseItems.push({ keyword: schemaKeywords.blob });
-          return baseItems;
-        case "date-time":
-          if (options.dateType) {
-            if (options.dateType === "date") {
-              baseItems.unshift({ keyword: schemaKeywords.date, args: { type: "date" } });
-              return baseItems;
-            }
-            if (options.dateType === "stringOffset") {
-              baseItems.unshift({ keyword: schemaKeywords.datetime, args: { offset: true } });
-              return baseItems;
-            }
-            if (options.dateType === "stringLocal") {
-              baseItems.unshift({ keyword: schemaKeywords.datetime, args: { local: true } });
-              return baseItems;
-            }
-            baseItems.unshift({ keyword: schemaKeywords.datetime, args: { offset: false } });
-            return baseItems;
-          }
-          break;
-        case "date":
-          if (options.dateType) {
-            if (options.dateType === "date") {
-              baseItems.unshift({ keyword: schemaKeywords.date, args: { type: "date" } });
-              return baseItems;
-            }
-            baseItems.unshift({ keyword: schemaKeywords.date, args: { type: "string" } });
-            return baseItems;
-          }
-          break;
-        case "time":
-          if (options.dateType) {
-            if (options.dateType === "date") {
-              baseItems.unshift({ keyword: schemaKeywords.time, args: { type: "date" } });
-              return baseItems;
-            }
-            baseItems.unshift({ keyword: schemaKeywords.time, args: { type: "string" } });
-            return baseItems;
-          }
-          break;
-        case "uuid":
-          baseItems.unshift({ keyword: schemaKeywords.uuid });
-          break;
-        case "email":
-        case "idn-email":
-          baseItems.unshift({ keyword: schemaKeywords.email });
-          break;
-        case "uri":
-        case "ipv4":
-        case "ipv6":
-        case "uri-reference":
-        case "hostname":
-        case "idn-hostname":
-          baseItems.unshift({ keyword: schemaKeywords.url });
-          break;
-      }
-    }
-    if ("items" in schema || schema.type === "array") {
-      const min2 = schema.minimum ?? schema.minLength ?? schema.minItems ?? void 0;
-      const max2 = schema.maximum ?? schema.maxLength ?? schema.maxItems ?? void 0;
-      const items = this.parse({ schema: "items" in schema ? schema.items : [], name, parentName });
-      return [
-        {
-          keyword: schemaKeywords.array,
-          args: {
-            items,
-            min: min2,
-            max: max2
-          }
-        },
-        ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max)
-      ];
-    }
-    if (schema.properties || schema.additionalProperties) {
-      return [...this.#parseProperties({ schema, name }), ...baseItems];
-    }
-    if (schema.type) {
-      if (Array.isArray(schema.type)) {
-        const [type] = schema.type;
-        return [
-          ...this.parse({
-            schema: {
-              ...schema,
-              type
-            },
-            name,
-            parentName
-          }),
-          ...baseItems
-        ].filter(Boolean);
-      }
-      if (!["boolean", "object", "number", "string", "integer"].includes(schema.type)) {
-        this.context.pluginManager.logger.emit("warning", `Schema type '${schema.type}' is not valid for schema ${parentName}.${name}`);
-      }
-      return [{ keyword: schema.type }, ...baseItems];
-    }
-    return [{ keyword: unknownReturn }];
-  }
-  async build(...generators) {
-    const { oas, contentType, include } = this.context;
-    const schemas = getSchemas({ oas, contentType, includes: include });
-    const promises = Object.entries(schemas).reduce((acc, [name, schema]) => {
-      const options = this.#getOptions({ name });
-      const promiseOperation = this.schema.call(this, name, schema, {
-        ...this.options,
-        ...options
-      });
-      if (promiseOperation) {
-        acc.push(promiseOperation);
-      }
-      generators?.forEach((generator) => {
-        const promise = generator.schema?.({
-          instance: this,
-          name,
-          schema,
-          options: {
-            ...this.options,
-            ...options
-          }
-        });
-        if (promise) {
-          acc.push(promise);
-        }
-      });
-      return acc;
-    }, []);
-    const files = await Promise.all(promises);
-    return files.flat().filter(Boolean);
-  }
-  /**
-   * Schema
-   */
-  async schema(name, object, options) {
-    return [];
-  }
-};
 
 // src/components/Operation.tsx
 init_esm_shims();
@@ -3784,9 +3098,6 @@ function Operation({ operation, children }) {
 }
 Operation.Context = OperationContext;
 
-// src/hooks/useSchema.ts
-init_esm_shims();
-
 // src/components/Schema.tsx
 init_esm_shims();
 var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
@@ -3797,82 +3108,9 @@ var SchemaContext = createContext({
 function Schema({ name, value, tree = [], children }) {
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(SchemaContext.Provider, { value: { name, schema: value, tree }, children });
 }
-Schema.File = function({ isTypeOnly, children }) {
-  const { plugin, pluginManager, mode } = useApp();
-  const { name } = useSchema();
-  if (mode === "single") {
-    const baseName2 = `${pluginManager.resolveName({
-      name,
-      pluginKey: plugin.key,
-      type: "file"
-    })}.ts`;
-    const resolvedPath2 = pluginManager.resolvePath({
-      baseName: "",
-      pluginKey: plugin.key
-    });
-    if (!resolvedPath2) {
-      return null;
-    }
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-      File,
-      {
-        baseName: baseName2,
-        path: resolvedPath2,
-        meta: {
-          pluginKey: plugin.key
-        },
-        children
-      }
-    );
-  }
-  const baseName = `${pluginManager.resolveName({
-    name,
-    pluginKey: plugin.key,
-    type: "file"
-  })}.ts`;
-  const resolvedPath = pluginManager.resolvePath({
-    baseName,
-    pluginKey: plugin.key
-  });
-  if (!resolvedPath) {
-    return null;
-  }
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
-    File,
-    {
-      baseName,
-      path: resolvedPath,
-      meta: {
-        pluginKey: plugin.key
-      },
-      children: [
-        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Schema.Imports, { isTypeOnly }),
-        children
-      ]
-    }
-  );
-};
-Schema.Imports = ({ isTypeOnly }) => {
-  const { tree } = useSchema();
-  const { path: root } = useFile();
-  const refs = SchemaGenerator.deepSearch(tree, schemaKeywords.ref);
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children: refs?.map((item, i) => {
-    if (!item.args.path) {
-      return void 0;
-    }
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(File.Import, { root, name: [item.args.name], path: item.args.path, isTypeOnly }, i);
-  }).filter(Boolean) });
-};
 Schema.Context = SchemaContext;
 
-// src/hooks/useSchema.ts
-function useSchema() {
-  const props = useContext(Schema.Context);
-  return props;
-}
-
 // src/components/Oas.tsx
-init_esm_shims();
 var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
 var OasContext = createContext({});
 function Oas({ oas, children, operations, generator }) {
@@ -3928,6 +3166,6 @@ react/cjs/react-jsx-runtime.development.js:
    *)
 */
 
-export { Oas, Operation, Schema, SchemaGenerator, isKeyword, require_jsx_runtime, schemaKeywords, useSchema };
-//# sourceMappingURL=chunk-M3V3WMCW.js.map
-//# sourceMappingURL=chunk-M3V3WMCW.js.map
+export { Oas, Operation, Schema, require_jsx_runtime };
+//# sourceMappingURL=chunk-CYF724QJ.js.map
+//# sourceMappingURL=chunk-CYF724QJ.js.map