@kubb/plugin-faker 4.21.1 → 4.22.0

package/dist/generators.d.ts

@@ -1,6 +1,462 @@
 import { t as __name } from "./chunk-eQyhnF5A.js";
-import { n as PluginFaker, r as ReactGenerator } from "./types-D8QPkAha.js";
+import { n as PluginFaker } from "./types-wnjXCmBP.js";
+import { BaseGenerator, Config, FileMetaBase, Group, KubbEvents, Output, Plugin, PluginFactoryOptions, PluginManager, ResolveNameParams } from "@kubb/core";
+import { Fabric } from "@kubb/react-fabric";
+import { FabricReactNode } from "@kubb/react-fabric/types";
+import { HttpMethod, Oas, Operation, SchemaObject, contentType } from "@kubb/oas";
+import { AsyncEventEmitter } from "@kubb/core/utils";
+import { KubbFile } from "@kubb/fabric-core/types";
 
+//#region ../plugin-oas/src/types.d.ts
+type GetOasOptions = {
+  validate?: boolean;
+};
+type Context$2 = {
+  getOas(options?: GetOasOptions): Promise<Oas>;
+  getBaseURL(): Promise<string | undefined>;
+};
+declare global {
+  namespace Kubb {
+    interface PluginContext extends Context$2 {}
+  }
+}
+/**
+ * `propertyName` is the ref name + resolved with the nameResolver
+ *  @example import { Pet } from './Pet'
+ *
+ * `originalName` is the original name used(in PascalCase), only used to remove duplicates
+ *
+ * `pluginKey` can be used to override the current plugin being used, handy when you want to import a type/schema out of another plugin
+ * @example import a type(plugin-ts) for a mock file(swagger-faker)
+ */
+type Ref = {
+  propertyName: string;
+  originalName: string;
+  path: KubbFile.Path;
+  pluginKey?: Plugin['key'];
+};
+type Refs = Record<string, Ref>;
+type OperationSchema = {
+  /**
+   * Converted name, contains already `PathParams`, `QueryParams`, ...
+   */
+  name: string;
+  schema: SchemaObject;
+  operation?: Operation;
+  /**
+   * OperationName in PascalCase, only being used in OperationGenerator
+   */
+  operationName: string;
+  description?: string;
+  statusCode?: number;
+  keys?: string[];
+  keysToOmit?: string[];
+  withData?: boolean;
+};
+type OperationSchemas = {
+  pathParams?: OperationSchema & {
+    keysToOmit?: never;
+  };
+  queryParams?: OperationSchema & {
+    keysToOmit?: never;
+  };
+  headerParams?: OperationSchema & {
+    keysToOmit?: never;
+  };
+  request?: OperationSchema;
+  response: OperationSchema;
+  responses: Array<OperationSchema>;
+  statusCodes?: Array<OperationSchema>;
+  errors?: Array<OperationSchema>;
+};
+type ByTag = {
+  type: 'tag';
+  pattern: string | RegExp;
+};
+type ByOperationId = {
+  type: 'operationId';
+  pattern: string | RegExp;
+};
+type ByPath = {
+  type: 'path';
+  pattern: string | RegExp;
+};
+type ByMethod = {
+  type: 'method';
+  pattern: HttpMethod | RegExp;
+};
+type BySchemaName = {
+  type: 'schemaName';
+  pattern: string | RegExp;
+};
+type ByContentType = {
+  type: 'contentType';
+  pattern: string | RegExp;
+};
+type Exclude = ByTag | ByOperationId | ByPath | ByMethod | ByContentType;
+type Include = ByTag | ByOperationId | ByPath | ByMethod | ByContentType;
+type Override<TOptions> = (ByTag | ByOperationId | ByPath | ByMethod | BySchemaName | ByContentType) & {
+  options: Partial<TOptions>;
+};
+//#endregion
+//#region ../plugin-oas/src/OperationGenerator.d.ts
+type Context$1<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+  fabric: Fabric;
+  oas: Oas;
+  exclude: Array<Exclude> | undefined;
+  include: Array<Include> | undefined;
+  override: Array<Override<TOptions>> | undefined;
+  contentType: contentType | undefined;
+  pluginManager: PluginManager;
+  events?: AsyncEventEmitter<KubbEvents>;
+  /**
+   * Current plugin
+   */
+  plugin: Plugin<TPluginOptions>;
+  mode: KubbFile.Mode;
+  UNSTABLE_NAMING?: true;
+};
+declare class OperationGenerator<TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TPluginOptions['resolvedOptions'], Context$1<TPluginOptions['resolvedOptions'], TPluginOptions>> {
+  #private;
+  getOptions(operation: Operation, method: HttpMethod): Partial<TPluginOptions['resolvedOptions']>;
+  getSchemas(operation: Operation, {
+    resolveName
+  }?: {
+    resolveName?: (name: string) => string;
+  }): OperationSchemas;
+  getOperations(): Promise<Array<{
+    path: string;
+    method: HttpMethod;
+    operation: Operation;
+  }>>;
+  build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>>;
+}
+//#endregion
+//#region ../plugin-oas/src/SchemaMapper.d.ts
+type SchemaKeywordMapper = {
+  object: {
+    keyword: 'object';
+    args: {
+      properties: {
+        [x: string]: Schema[];
+      };
+      additionalProperties: Schema[];
+      patternProperties?: Record<string, 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: KubbFile.Path;
+      /**
+       * When true `File.Import` is used.
+       * When false a reference is 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;
+  };
+  exclusiveMaximum: {
+    keyword: 'exclusiveMaximum';
+    args: number;
+  };
+  exclusiveMinimum: {
+    keyword: 'exclusiveMinimum';
+    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';
+  };
+};
+type Schema = {
+  keyword: string;
+} | SchemaKeywordMapper[keyof SchemaKeywordMapper];
+//#endregion
+//#region ../plugin-oas/src/SchemaGenerator.d.ts
+type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+  fabric: Fabric;
+  oas: Oas;
+  pluginManager: PluginManager;
+  events?: AsyncEventEmitter<KubbEvents>;
+  /**
+   * Current plugin
+   */
+  plugin: Plugin<TPluginOptions>;
+  mode: KubbFile.Mode;
+  include?: Array<'schemas' | 'responses' | 'requestBodies'>;
+  override: Array<Override<TOptions>> | undefined;
+  contentType?: contentType;
+  output?: string;
+};
+type SchemaGeneratorOptions = {
+  dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
+  unknownType: 'any' | 'unknown' | 'void';
+  emptySchemaType: 'any' | 'unknown' | 'void';
+  enumType?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal' | 'inlineLiteral';
+  enumSuffix?: string;
+  /**
+   * @deprecated Will be removed in v5. Use `collisionDetection: true` instead to prevent enum name collisions.
+   * When `collisionDetection` is enabled, the rootName-based approach eliminates the need for numeric suffixes.
+   * @internal
+   */
+  usedEnumNames?: Record<string, number>;
+  mapper?: Record<string, string>;
+  typed?: boolean;
+  transformers: {
+    /**
+     * Customize the names based on the type that is provided by the plugin.
+     */
+    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+    /**
+     * Receive schema and name(propertyName) and return FakerMeta array
+     * TODO TODO add docs
+     * @beta
+     */
+    schema?: (schemaProps: SchemaProps$1, defaultSchemas: Schema[]) => Array<Schema> | undefined;
+  };
+};
+type SchemaProps$1 = {
+  schema: SchemaObject | null;
+  name: string | null;
+  parentName: string | null;
+  rootName?: string | null;
+};
+declare class SchemaGenerator<TOptions extends SchemaGeneratorOptions = SchemaGeneratorOptions, TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TOptions, Context<TOptions, TPluginOptions>> {
+  #private;
+  refs: Refs;
+  /**
+   * Creates a type node from a given schema.
+   * Delegates to getBaseTypeFromSchema internally and
+   * optionally adds a union with null.
+   */
+  parse(props: SchemaProps$1): Schema[];
+  static deepSearch<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): Array<SchemaKeywordMapper[T]>;
+  static find<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined;
+  static combineObjects(tree: Schema[] | undefined): Schema[];
+  build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>>;
+}
+//#endregion
+//#region ../plugin-oas/src/generators/createGenerator.d.ts
+type CoreGenerator<TOptions extends PluginFactoryOptions> = {
+  name: string;
+  type: 'core';
+  operations: (props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>;
+  operation: (props: OperationProps<TOptions>) => Promise<KubbFile.File[]>;
+  schema: (props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>;
+};
+//#endregion
+//#region ../plugin-oas/src/generators/types.d.ts
+type OperationsProps<TOptions extends PluginFactoryOptions> = {
+  config: Config;
+  generator: Omit<OperationGenerator<TOptions>, 'build'>;
+  plugin: Plugin<TOptions>;
+  operations: Array<Operation>;
+};
+type OperationProps<TOptions extends PluginFactoryOptions> = {
+  config: Config;
+  generator: Omit<OperationGenerator<TOptions>, 'build'>;
+  plugin: Plugin<TOptions>;
+  operation: Operation;
+};
+type SchemaProps<TOptions extends PluginFactoryOptions> = {
+  config: Config;
+  generator: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>;
+  plugin: Plugin<TOptions>;
+  schema: {
+    name: string;
+    tree: Array<Schema>;
+    value: SchemaObject;
+  };
+};
+type Generator<TOptions extends PluginFactoryOptions> = CoreGenerator<TOptions> | ReactGenerator<TOptions>;
+//#endregion
+//#region ../plugin-oas/src/generators/createReactGenerator.d.ts
+type ReactGenerator<TOptions extends PluginFactoryOptions> = {
+  name: string;
+  type: 'react';
+  Operations: (props: OperationsProps<TOptions>) => FabricReactNode;
+  Operation: (props: OperationProps<TOptions>) => FabricReactNode;
+  Schema: (props: SchemaProps<TOptions>) => FabricReactNode;
+};
+//#endregion
 //#region src/generators/fakerGenerator.d.ts
 declare const fakerGenerator: ReactGenerator<PluginFaker>;
 //#endregion

package/dist/generators.js

@@ -1,3 +1,3 @@
-import { t as fakerGenerator } from "./fakerGenerator-VqIrrE7d.js";
+import { t as fakerGenerator } from "./fakerGenerator-BWH5M054.js";
 
 export { fakerGenerator };

package/dist/index.cjs

@@ -1,5 +1,5 @@
-const require_components = require('./components-CQqf9rBj.cjs');
-const require_fakerGenerator = require('./fakerGenerator-BC_ilj8m.cjs');
+const require_components = require('./components-D44-YPpj.cjs');
+const require_fakerGenerator = require('./fakerGenerator-DipEvGPU.cjs');
 let node_path = require("node:path");
 node_path = require_components.__toESM(node_path);
 let _kubb_core = require("@kubb/core");

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { a as __name, n as PluginFaker, t as Options } from "./types-CB26F0zP.cjs";
+import { n as PluginFaker, r as __name, t as Options } from "./types-DPGJaaLM.cjs";
 import * as _kubb_core0 from "@kubb/core";
 
 //#region src/plugin.d.ts

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { t as __name } from "./chunk-eQyhnF5A.js";
-import { n as PluginFaker, t as Options } from "./types-D8QPkAha.js";
+import { n as PluginFaker, t as Options } from "./types-wnjXCmBP.js";
 import * as _kubb_core0 from "@kubb/core";
 
 //#region src/plugin.d.ts

package/dist/index.js

@@ -1,5 +1,5 @@
 import { t as __name } from "./chunk-eQyhnF5A.js";
-import { t as fakerGenerator } from "./fakerGenerator-VqIrrE7d.js";
+import { t as fakerGenerator } from "./fakerGenerator-BWH5M054.js";
 import path from "node:path";
 import { definePlugin, getBarrelFiles, getMode } from "@kubb/core";
 import { camelCase } from "@kubb/core/transformers";

package/dist/types-DPGJaaLM.d.cts

@@ -0,0 +1,124 @@
+import { Exclude, Include, Override, ResolvePathOptions, Schema } from "@kubb/plugin-oas";
+import { Group, Output, PluginFactoryOptions, ResolveNameParams } from "@kubb/core";
+import { Oas, SchemaObject, contentType } from "@kubb/oas";
+import { Generator } from "@kubb/plugin-oas/generators";
+
+//#region rolldown:runtime
+//#endregion
+//#region src/types.d.ts
+type Options = {
+  /**
+   * Specify the export location for the files and define the behavior of the output
+   * @default { path: 'handlers', barrelType: 'named' }
+   */
+  output?: Output<Oas>;
+  /**
+   * Define which contentType should be used.
+   * By default, the first JSON valid mediaType is used
+   */
+  contentType?: contentType;
+  /**
+   * Group the Faker mocks based on the provided name.
+   */
+  group?: Group;
+  /**
+   * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
+   */
+  exclude?: Array<Exclude>;
+  /**
+   * Array containing include parameters to include tags/operations/methods/paths.
+   */
+  include?: Array<Include>;
+  /**
+   * Array containing override parameters to override `options` based on tags/operations/methods/paths.
+   */
+  override?: Array<Override<ResolvedOptions>>;
+  /**
+   * Choose to use date or datetime as JavaScript Date instead of string.
+   * - 'string' represents dates as string values.
+   * - 'date' represents dates as JavaScript Date objects.
+   * @default 'string'
+   */
+  dateType?: 'string' | 'date';
+  /**
+   * Which parser should be used when dateType is set to string.
+   * - 'faker' uses faker's built-in date formatting methods.
+   * - 'dayjs' uses dayjs for date formatting with custom patterns.
+   * - 'moment' uses moment for date formatting with custom patterns.
+   * @default 'faker'
+   */
+  dateParser?: 'faker' | 'dayjs' | 'moment' | (string & {});
+  /**
+   * Which type to use when the Swagger/OpenAPI file is not providing more information.
+   * - 'any' allows any value.
+   * - 'unknown' requires type narrowing before use.
+   * - 'void' represents no value.
+   * @default 'any'
+   */
+  unknownType?: 'any' | 'unknown' | 'void';
+  /**
+   * Which type to use for empty schema values.
+   * - 'any' allows any value.
+   * - 'unknown' requires type narrowing before use.
+   * - 'void' represents no value.
+   * @default `unknownType`
+   */
+  emptySchemaType?: 'any' | 'unknown' | 'void';
+  /**
+   * Choose which generator to use when using Regexp.
+   * - 'faker' uses faker.helpers.fromRegExp for generating values from regex patterns.
+   * - 'randexp' uses RandExp library for generating values from regex patterns.
+   * @default 'faker'
+   */
+  regexGenerator?: 'faker' | 'randexp';
+  mapper?: Record<string, string>;
+  /**
+   * The use of Seed is intended to allow for consistent values in a test.
+   */
+  seed?: number | number[];
+  /**
+   * Transform parameter names to a specific casing format.
+   * When set to 'camelcase', parameter names in path, query, and header params will be transformed to camelCase.
+   * This should match the paramsCasing setting used in @kubb/plugin-ts.
+   * @default undefined
+   */
+  paramsCasing?: 'camelcase';
+  transformers?: {
+    /**
+     * Customize the names based on the type that is provided by the plugin.
+     */
+    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+    /**
+     * Receive schema and baseName(propertyName) and return FakerMeta array
+     * TODO TODO add docs
+     * @beta
+     */
+    schema?: (props: {
+      schema: SchemaObject | null;
+      name: string | null;
+      parentName: string | null;
+    }, defaultSchemas: Schema[]) => Schema[] | undefined;
+  };
+  /**
+   * Define some generators next to the faker generators
+   */
+  generators?: Array<Generator<PluginFaker>>;
+};
+type ResolvedOptions = {
+  output: Output<Oas>;
+  group: Options['group'];
+  override: NonNullable<Options['override']>;
+  dateType: NonNullable<Options['dateType']>;
+  dateParser: NonNullable<Options['dateParser']>;
+  unknownType: NonNullable<Options['unknownType']>;
+  emptySchemaType: NonNullable<Options['emptySchemaType']>;
+  transformers: NonNullable<Options['transformers']>;
+  seed: NonNullable<Options['seed']> | undefined;
+  mapper: NonNullable<Options['mapper']>;
+  regexGenerator: NonNullable<Options['regexGenerator']>;
+  paramsCasing: Options['paramsCasing'];
+};
+type PluginFaker = PluginFactoryOptions<'plugin-faker', Options, ResolvedOptions, never, ResolvePathOptions>;
+//#endregion
+export { PluginFaker as n, __name as r, Options as t };
+//# sourceMappingURL=types-DPGJaaLM.d.cts.map