@kubb/plugin-oas 3.16.2 → 3.16.4

package/dist/SchemaMapper-C2J2d3o4.d.ts

@@ -0,0 +1,388 @@
+//#region ../core/src/fs/types.d.ts
+type BasePath<T extends string = string> = `${T}/`;
+type Import = {
+  /**
+   * Import name to be used
+   * @example ["useState"]
+   * @example "React"
+   */
+  name: string | Array<string | {
+    propertyName: string;
+    name?: string;
+  }>;
+  /**
+   * Path for the import
+   * @example '@kubb/core'
+   */
+  path: string;
+  /**
+   * Add `type` prefix to the import, this will result in: `import type { Type } from './path'`.
+   */
+  isTypeOnly?: boolean;
+  isNameSpace?: boolean;
+  /**
+   * When root is set it will get the path with relative getRelativePath(root, path).
+   */
+  root?: string;
+};
+type Source = {
+  name?: string;
+  value?: string;
+  isTypeOnly?: boolean;
+  /**
+   * Has const or type 'export'
+   * @default false
+   */
+  isExportable?: boolean;
+  /**
+   * When set, barrel generation will add this
+   * @default false
+   */
+  isIndexable?: boolean;
+};
+type Export = {
+  /**
+   * Export name to be used.
+   * @example ["useState"]
+   * @example "React"
+   */
+  name?: string | Array<string>;
+  /**
+   * Path for the import.
+   * @example '@kubb/core'
+   */
+  path: string;
+  /**
+   * Add `type` prefix to the export, this will result in: `export type { Type } from './path'`.
+   */
+  isTypeOnly?: boolean;
+  /**
+   * Make it possible to override the name, this will result in: `export * as aliasName from './path'`.
+   */
+  asAlias?: boolean;
+};
+type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`;
+type Mode = 'single' | 'split';
+/**
+ * Name to be used to dynamicly create the baseName(based on input.path)
+ * Based on UNIX basename
+ * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
+ */
+type BaseName = `${string}.${string}`;
+/**
+ * Path will be full qualified path to a specified file
+ */
+type Path = string;
+type AdvancedPath<T extends BaseName = BaseName> = `${BasePath}${T}`;
+type OptionalPath = Path | undefined | null;
+type File<TMeta extends object = object> = {
+  /**
+   * Name to be used to create the path
+   * Based on UNIX basename, `${name}.extname`
+   * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
+   */
+  baseName: BaseName;
+  /**
+   * Path will be full qualified path to a specified file
+   */
+  path: AdvancedPath<BaseName> | Path;
+  sources: Array<Source>;
+  imports?: Array<Import>;
+  exports?: Array<Export>;
+  /**
+   * Use extra meta, this is getting used to generate the barrel/index files.
+   */
+  meta?: TMeta;
+  banner?: string;
+  footer?: string;
+};
+type ResolvedImport = Import;
+type ResolvedExport = Export;
+type ResolvedFile<TMeta extends object = object> = File<TMeta> & {
+  /**
+   * @default object-hash
+   */
+  id: string;
+  /**
+   * Contains the first part of the baseName, generated based on baseName
+   * @link  https://nodejs.org/api/path.html#pathformatpathobject
+   */
+  name: string;
+  extname: Extname;
+  imports: Array<ResolvedImport>;
+  exports: Array<ResolvedExport>;
+};
+//#endregion
+//#region src/SchemaMapper.d.ts
+type SchemaKeywordMapper = {
+  object: {
+    keyword: 'object';
+    args: {
+      properties: {
+        [x: string]: Schema[];
+      };
+      additionalProperties: Schema[];
+      strict?: boolean;
+    };
+  };
+  url: {
+    keyword: 'url';
+  };
+  readOnly: {
+    keyword: 'readOnly';
+  };
+  writeOnly: {
+    keyword: 'writeOnly';
+  };
+  uuid: {
+    keyword: 'uuid';
+  };
+  email: {
+    keyword: 'email';
+  };
+  firstName: {
+    keyword: 'firstName';
+  };
+  lastName: {
+    keyword: 'lastName';
+  };
+  phone: {
+    keyword: 'phone';
+  };
+  password: {
+    keyword: 'password';
+  };
+  date: {
+    keyword: 'date';
+    args: {
+      type?: 'date' | 'string';
+    };
+  };
+  time: {
+    keyword: 'time';
+    args: {
+      type?: 'date' | 'string';
+    };
+  };
+  datetime: {
+    keyword: 'datetime';
+    args: {
+      offset?: boolean;
+      local?: boolean;
+    };
+  };
+  tuple: {
+    keyword: 'tuple';
+    args: {
+      items: Schema[];
+      min?: number;
+      max?: number;
+      rest?: Schema;
+    };
+  };
+  array: {
+    keyword: 'array';
+    args: {
+      items: Schema[];
+      min?: number;
+      max?: number;
+      unique?: boolean;
+    };
+  };
+  enum: {
+    keyword: 'enum';
+    args: {
+      name: string;
+      typeName: string;
+      asConst: boolean;
+      items: Array<{
+        name: string | number;
+        format: 'string' | 'number' | 'boolean';
+        value?: string | number | boolean;
+      }>;
+    };
+  };
+  and: {
+    keyword: 'and';
+    args: Schema[];
+  };
+  const: {
+    keyword: 'const';
+    args: {
+      name: string | number;
+      format: 'string' | 'number' | 'boolean';
+      value?: string | number | boolean;
+    };
+  };
+  union: {
+    keyword: 'union';
+    args: Schema[];
+  };
+  ref: {
+    keyword: 'ref';
+    args: {
+      name: string;
+      $ref: string;
+      /**
+       * Full qualified path.
+       */
+      path: OptionalPath;
+      /**
+       * When true `File.Import` will be used.
+       * When false a reference will be used inside the current file.
+       */
+      isImportable: boolean;
+    };
+  };
+  matches: {
+    keyword: 'matches';
+    args?: string;
+  };
+  boolean: {
+    keyword: 'boolean';
+  };
+  default: {
+    keyword: 'default';
+    args: string | number | boolean;
+  };
+  string: {
+    keyword: 'string';
+  };
+  integer: {
+    keyword: 'integer';
+  };
+  number: {
+    keyword: 'number';
+  };
+  max: {
+    keyword: 'max';
+    args: number;
+  };
+  min: {
+    keyword: 'min';
+    args: number;
+  };
+  describe: {
+    keyword: 'describe';
+    args: string;
+  };
+  example: {
+    keyword: 'example';
+    args: string;
+  };
+  deprecated: {
+    keyword: 'deprecated';
+  };
+  optional: {
+    keyword: 'optional';
+  };
+  undefined: {
+    keyword: 'undefined';
+  };
+  nullish: {
+    keyword: 'nullish';
+  };
+  nullable: {
+    keyword: 'nullable';
+  };
+  null: {
+    keyword: 'null';
+  };
+  any: {
+    keyword: 'any';
+  };
+  unknown: {
+    keyword: 'unknown';
+  };
+  void: {
+    keyword: 'void';
+  };
+  blob: {
+    keyword: 'blob';
+  };
+  schema: {
+    keyword: 'schema';
+    args: {
+      type: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object';
+      format?: string;
+    };
+  };
+  name: {
+    keyword: 'name';
+    args: string;
+  };
+  catchall: {
+    keyword: 'catchall';
+  };
+  interface: {
+    keyword: 'interface';
+  };
+};
+declare const schemaKeywords: {
+  any: "any";
+  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";
+  void: "void";
+  default: "default";
+  const: "const";
+  and: "and";
+  describe: "describe";
+  min: "min";
+  max: "max";
+  optional: "optional";
+  readOnly: "readOnly";
+  writeOnly: "writeOnly";
+  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";
+  interface: "interface";
+};
+type SchemaKeyword = keyof SchemaKeywordMapper;
+type SchemaMapper<T = string | null | undefined> = { [K in keyof SchemaKeywordMapper]: (() => T | undefined) | undefined };
+type SchemaKeywordBase<T> = {
+  keyword: SchemaKeyword;
+  args: T;
+};
+type Schema = {
+  keyword: string;
+} | SchemaKeywordMapper[keyof SchemaKeywordMapper];
+type SchemaTree = {
+  parent: Schema | undefined;
+  current: Schema;
+  siblings: Schema[];
+  /**
+   * this will be equal to the key of a property(object)
+   */
+  name?: string;
+};
+declare function isKeyword<T extends Schema, K extends keyof SchemaKeywordMapper>(meta: T, keyword: K): meta is Extract<T, SchemaKeywordMapper[K]>;
+//#endregion
+export { BaseName, Extname, File, Import, Mode, OptionalPath, Path, ResolvedFile, Schema, SchemaKeyword, SchemaKeywordBase, SchemaKeywordMapper, SchemaMapper, SchemaTree, isKeyword, schemaKeywords };
+//# sourceMappingURL=SchemaMapper-C2J2d3o4.d.ts.map

package/dist/SchemaMapper-D8J0V9Pj.cjs

@@ -0,0 +1,66 @@
+
+//#region src/SchemaMapper.ts
+const schemaKeywords = {
+	any: "any",
+	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",
+	void: "void",
+	default: "default",
+	const: "const",
+	and: "and",
+	describe: "describe",
+	min: "min",
+	max: "max",
+	optional: "optional",
+	readOnly: "readOnly",
+	writeOnly: "writeOnly",
+	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",
+	interface: "interface"
+};
+function isKeyword(meta, keyword) {
+	return meta.keyword === keyword;
+}
+
+//#endregion
+Object.defineProperty(exports, 'isKeyword', {
+  enumerable: true,
+  get: function () {
+    return isKeyword;
+  }
+});
+Object.defineProperty(exports, 'schemaKeywords', {
+  enumerable: true,
+  get: function () {
+    return schemaKeywords;
+  }
+});
+//# sourceMappingURL=SchemaMapper-D8J0V9Pj.cjs.map

package/dist/SchemaMapper-D8J0V9Pj.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaMapper-D8J0V9Pj.cjs","names":["meta: T","keyword: K"],"sources":["../src/SchemaMapper.ts"],"sourcesContent":["import type { KubbFile } from '@kubb/core/fs'\n\nexport type SchemaKeywordMapper = {\n  object: {\n    keyword: 'object'\n    args: {\n      properties: { [x: string]: Schema[] }\n      additionalProperties: Schema[]\n      strict?: boolean\n    }\n  }\n  url: { keyword: 'url' }\n  readOnly: { keyword: 'readOnly' }\n  writeOnly: { keyword: 'writeOnly' }\n  uuid: { keyword: 'uuid' }\n  email: { keyword: 'email' }\n  firstName: { keyword: 'firstName' }\n  lastName: { keyword: 'lastName' }\n  phone: { keyword: 'phone' }\n  password: { keyword: 'password' }\n  date: { keyword: 'date'; args: { type?: 'date' | 'string' } }\n  time: { keyword: 'time'; args: { type?: 'date' | 'string' } }\n  datetime: { keyword: 'datetime'; args: { offset?: boolean; local?: boolean } }\n  tuple: { keyword: 'tuple'; args: { items: Schema[]; min?: number; max?: number; rest?: Schema } }\n  array: {\n    keyword: 'array'\n    args: { items: Schema[]; min?: number; max?: number; unique?: boolean }\n  }\n  enum: {\n    keyword: 'enum'\n    args: {\n      name: string\n      typeName: string\n      asConst: boolean\n      items: Array<{\n        name: string | number\n        format: 'string' | 'number' | 'boolean'\n        value?: string | number | boolean\n      }>\n    }\n  }\n  and: { keyword: 'and'; args: Schema[] }\n  const: {\n    keyword: 'const'\n    args: {\n      name: string | number\n      format: 'string' | 'number' | 'boolean'\n      value?: string | number | boolean\n    }\n  }\n  union: { keyword: 'union'; args: Schema[] }\n  ref: {\n    keyword: 'ref'\n    args: {\n      name: string\n      $ref: string\n      /**\n       * Full qualified path.\n       */\n      path: KubbFile.OptionalPath\n      /**\n       * When true `File.Import` will be used.\n       * When false a reference will be used inside the current file.\n       */\n      isImportable: boolean\n    }\n  }\n  matches: { keyword: 'matches'; args?: string }\n  boolean: { keyword: 'boolean' }\n  default: { keyword: 'default'; args: string | number | boolean }\n  string: { keyword: 'string' }\n  integer: { keyword: 'integer' }\n  number: { keyword: 'number' }\n  max: { keyword: 'max'; args: number }\n  min: { keyword: 'min'; args: number }\n  describe: { keyword: 'describe'; args: string }\n  example: { keyword: 'example'; args: string }\n  deprecated: { keyword: 'deprecated' }\n  optional: { keyword: 'optional' }\n  undefined: { keyword: 'undefined' }\n  nullish: { keyword: 'nullish' }\n  nullable: { keyword: 'nullable' }\n  null: { keyword: 'null' }\n  any: { keyword: 'any' }\n  unknown: { keyword: 'unknown' }\n  void: { keyword: 'void' }\n  blob: { keyword: 'blob' }\n  schema: { keyword: 'schema'; args: { type: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object'; format?: string } }\n  name: { keyword: 'name'; args: string }\n  catchall: { keyword: 'catchall' }\n  interface: { keyword: 'interface' }\n}\n\nexport const schemaKeywords = {\n  any: 'any',\n  unknown: 'unknown',\n  number: 'number',\n  integer: 'integer',\n  string: 'string',\n  boolean: 'boolean',\n  undefined: 'undefined',\n  nullable: 'nullable',\n  null: 'null',\n  nullish: 'nullish',\n  array: 'array',\n  tuple: 'tuple',\n  enum: 'enum',\n  union: 'union',\n  datetime: 'datetime',\n  date: 'date',\n  email: 'email',\n  uuid: 'uuid',\n  url: 'url',\n  void: 'void',\n  /* intersection */\n  default: 'default',\n  const: 'const',\n  and: 'and',\n  describe: 'describe',\n  min: 'min',\n  max: 'max',\n  optional: 'optional',\n  readOnly: 'readOnly',\n  writeOnly: 'writeOnly',\n\n  // custom ones\n  object: 'object',\n  ref: 'ref',\n  matches: 'matches',\n  firstName: 'firstName',\n  lastName: 'lastName',\n  password: 'password',\n  phone: 'phone',\n  blob: 'blob',\n  deprecated: 'deprecated',\n  example: 'example',\n  schema: 'schema',\n  catchall: 'catchall',\n  time: 'time',\n  name: 'name',\n  interface: 'interface',\n} satisfies {\n  [K in keyof SchemaKeywordMapper]: SchemaKeywordMapper[K]['keyword']\n}\n\nexport type SchemaKeyword = keyof SchemaKeywordMapper\n\nexport type SchemaMapper<T = string | null | undefined> = {\n  [K in keyof SchemaKeywordMapper]: (() => T | undefined) | undefined\n}\n\nexport type SchemaKeywordBase<T> = {\n  keyword: SchemaKeyword\n  args: T\n}\n\nexport type Schema = { keyword: string } | SchemaKeywordMapper[keyof SchemaKeywordMapper]\n\nexport type SchemaTree = {\n  parent: Schema | undefined\n  current: Schema\n  siblings: Schema[]\n  /**\n   * this will be equal to the key of a property(object)\n   */\n  name?: string\n}\n\nexport function isKeyword<T extends Schema, K extends keyof SchemaKeywordMapper>(meta: T, keyword: K): meta is Extract<T, SchemaKeywordMapper[K]> {\n  return meta.keyword === keyword\n}\n"],"mappings":";;AA6FA,MAAa,iBAAiB;CAC5B,KAAK;CACL,SAAS;CACT,QAAQ;CACR,SAAS;CACT,QAAQ;CACR,SAAS;CACT,WAAW;CACX,UAAU;CACV,MAAM;CACN,SAAS;CACT,OAAO;CACP,OAAO;CACP,MAAM;CACN,OAAO;CACP,UAAU;CACV,MAAM;CACN,OAAO;CACP,MAAM;CACN,KAAK;CACL,MAAM;CAEN,SAAS;CACT,OAAO;CACP,KAAK;CACL,UAAU;CACV,KAAK;CACL,KAAK;CACL,UAAU;CACV,UAAU;CACV,WAAW;CAGX,QAAQ;CACR,KAAK;CACL,SAAS;CACT,WAAW;CACX,UAAU;CACV,UAAU;CACV,OAAO;CACP,MAAM;CACN,YAAY;CACZ,SAAS;CACT,QAAQ;CACR,UAAU;CACV,MAAM;CACN,MAAM;CACN,WAAW;AACZ;AA2BD,SAAgB,UAAiEA,MAASC,SAAwD;AAChJ,QAAO,KAAK,YAAY;AACzB"}

package/dist/chunk-CUT6urMc.cjs

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/components.cjs

@@ -1,20 +1,5 @@
-'use strict';
+const require_Oas = require('./Oas-Cv_pyXRM.cjs');
 
-var chunkZ2NREI4X_cjs = require('./chunk-Z2NREI4X.cjs');
-
-
-
-Object.defineProperty(exports, "Oas", {
-  enumerable: true,
-  get: function () { return chunkZ2NREI4X_cjs.Oas; }
-});
-Object.defineProperty(exports, "Operation", {
-  enumerable: true,
-  get: function () { return chunkZ2NREI4X_cjs.Operation; }
-});
-Object.defineProperty(exports, "Schema", {
-  enumerable: true,
-  get: function () { return chunkZ2NREI4X_cjs.Schema; }
-});
-//# sourceMappingURL=components.cjs.map
-//# sourceMappingURL=components.cjs.map
+exports.Oas = require_Oas.Oas;
+exports.Operation = require_Oas.Operation;
+exports.Schema = require_Oas.Schema;

package/dist/components.d.cts

@@ -1,46 +1,53 @@
-import { S as Schema } from './Schema-M6983FL1.cjs';
-import * as react from 'react';
-import { Operation as Operation$1, Oas as Oas$1 } from '@kubb/oas';
-import { KubbNode } from '@kubb/react/types';
-import { b as OperationGenerator } from './OperationGenerator-DJE2XQ83.cjs';
-import './SchemaMapper-B21ZmWag.cjs';
-import '@kubb/core/fs';
-import '@kubb/core';
+import { KubbNode, Oas, Operation, OperationGenerator } from "./OperationGenerator-CgbXErhW.cjs";
+import "./SchemaMapper-BiagBQN4.cjs";
+import { Schema } from "./Schema-DJshqHto.cjs";
+import * as react1 from "react";
 
+//#region src/components/Operation.d.ts
 type Props$1 = {
-    operation: Operation$1;
-    children?: KubbNode;
+  operation: Operation;
+  children?: KubbNode;
 };
 type OperationContextProps = {
-    operation?: Operation$1;
+  operation?: Operation;
 };
-declare function Operation({ operation, children }: Props$1): any;
-declare namespace Operation {
-    var Context: react.Context<OperationContextProps>;
+declare function Operation$1({
+  operation,
+  children
+}: Props$1): any;
+declare namespace Operation$1 {
+  var Context: react1.Context<OperationContextProps>;
 }
-
+//#endregion
+//#region src/components/Oas.d.ts
 type Props = {
-    oas: Oas$1;
-    operations?: Operation$1[];
-    /**
-     * @deprecated
-     */
-    generator?: Omit<OperationGenerator, 'build'>;
-    children?: KubbNode;
+  oas: Oas;
+  operations?: Operation[];
+  /**
+   * @deprecated
+   */
+  generator?: Omit<OperationGenerator, 'build'>;
+  children?: KubbNode;
 };
 type OasContextProps = {
-    oas?: Oas$1;
-    operations?: Operation$1[];
-    /**
-     * @deprecated
-     */
-    generator?: Omit<OperationGenerator, 'build'>;
+  oas?: Oas;
+  operations?: Operation[];
+  /**
+   * @deprecated
+   */
+  generator?: Omit<OperationGenerator, 'build'>;
 };
-declare function Oas({ oas, children, operations, generator }: Props): any;
-declare namespace Oas {
-    var Context: react.Context<OasContextProps>;
-    var Operation: typeof Operation;
-    var Schema: typeof Schema;
+declare function Oas$1({
+  oas,
+  children,
+  operations,
+  generator
+}: Props): any;
+declare namespace Oas$1 {
+  var Context: react1.Context<OasContextProps>;
+  var Operation: typeof Operation$1;
+  var Schema: typeof Schema;
 }
-
-export { Oas, Operation, Schema };
+//#endregion
+export { Oas$1 as Oas, Operation$1 as Operation, Schema };
+//# sourceMappingURL=components.d.cts.map