@kubb/plugin-faker 3.0.0-alpha.14 → 3.0.0-alpha.16

package/dist/components.d.cts

@@ -1,23 +1,21 @@
-import { ReactNode } from 'react';
-
-type Props$1 = {
-    description?: string;
-};
-declare function OperationSchema({ description }: Props$1): ReactNode;
-declare namespace OperationSchema {
-    var File: ({}: FileProps$1) => ReactNode;
-}
-type FileProps$1 = {};
+import { Schema } from '@kubb/plugin-oas';
+import { KubbNode } from '@kubb/react/types';
+import { P as PluginFaker } from './types-DrJPCRvZ.cjs';
+import '@kubb/core';
+import '@kubb/fs/types';
+import '@kubb/oas';
 
 type Props = {
+    name: string;
+    typeName: string;
+    tree: Array<Schema>;
+    seed?: PluginFaker['options']['seed'];
     description?: string;
-    withData?: boolean;
+    regexGenerator?: PluginFaker['options']['regexGenerator'];
+    mapper?: PluginFaker['options']['mapper'];
+    dateParser?: PluginFaker['options']['dateParser'];
+    canOverride: boolean;
 };
-declare function Schema(props: Props): ReactNode;
-declare namespace Schema {
-    var File: ({}: FileProps) => ReactNode;
-    var Imports: () => ReactNode;
-}
-type FileProps = {};
+declare function Faker({ tree, description, name, typeName, seed, regexGenerator, canOverride, mapper, dateParser }: Props): KubbNode;
 
-export { OperationSchema, Schema };
+export { Faker };

package/dist/components.d.ts

@@ -1,23 +1,21 @@
-import { ReactNode } from 'react';
-
-type Props$1 = {
-    description?: string;
-};
-declare function OperationSchema({ description }: Props$1): ReactNode;
-declare namespace OperationSchema {
-    var File: ({}: FileProps$1) => ReactNode;
-}
-type FileProps$1 = {};
+import { Schema } from '@kubb/plugin-oas';
+import { KubbNode } from '@kubb/react/types';
+import { P as PluginFaker } from './types-DrJPCRvZ.js';
+import '@kubb/core';
+import '@kubb/fs/types';
+import '@kubb/oas';
 
 type Props = {
+    name: string;
+    typeName: string;
+    tree: Array<Schema>;
+    seed?: PluginFaker['options']['seed'];
     description?: string;
-    withData?: boolean;
+    regexGenerator?: PluginFaker['options']['regexGenerator'];
+    mapper?: PluginFaker['options']['mapper'];
+    dateParser?: PluginFaker['options']['dateParser'];
+    canOverride: boolean;
 };
-declare function Schema(props: Props): ReactNode;
-declare namespace Schema {
-    var File: ({}: FileProps) => ReactNode;
-    var Imports: () => ReactNode;
-}
-type FileProps = {};
+declare function Faker({ tree, description, name, typeName, seed, regexGenerator, canOverride, mapper, dateParser }: Props): KubbNode;
 
-export { OperationSchema, Schema };
+export { Faker };

package/dist/components.js

@@ -1,530 +1,3 @@
-import { Oas } from '@kubb/plugin-oas/components';
-import { useSchema, useOas, useOperationManager, useOperation } from '@kubb/plugin-oas/hooks';
-import { pluginTsName } from '@kubb/plugin-ts';
-import { createRoot, App, useApp, File, Function, useFile } from '@kubb/react';
-import { pluginOasName, SchemaGenerator, OperationGenerator as OperationGenerator$1, schemaKeywords, isKeyword } from '@kubb/plugin-oas';
-import transformers, { camelCase } from '@kubb/core/transformers';
-import path from 'node:path';
-import { createPlugin, FileManager, PluginManager } from '@kubb/core';
-import { renderTemplate } from '@kubb/core/utils';
-import { jsx, jsxs, Fragment } from '@kubb/react/jsx-runtime';
-
-// src/components/OperationSchema.tsx
-var fakerKeywordMapper = {
-  any: () => "undefined",
-  unknown: () => "unknown",
-  number: (min, max) => {
-    if (max !== void 0 && min !== void 0) {
-      return `faker.number.float({ min: ${min}, max: ${max} })`;
-    }
-    if (min !== void 0) {
-      return `faker.number.float({ min: ${min} })`;
-    }
-    if (max !== void 0) {
-      return `faker.number.float({ max: ${max} })`;
-    }
-    return "faker.number.float()";
-  },
-  integer: (min, max) => {
-    if (max !== void 0 && min !== void 0) {
-      return `faker.number.int({ min: ${min}, max: ${max} })`;
-    }
-    if (min !== void 0) {
-      return `faker.number.int({ min: ${min} })`;
-    }
-    if (max !== void 0) {
-      return `faker.number.int({ max: ${max} })`;
-    }
-    return "faker.number.int()";
-  },
-  string: (min, max) => {
-    if (max !== void 0 && min !== void 0) {
-      return `faker.string.alpha({ length: { min: ${min}, max: ${max} } })`;
-    }
-    if (min !== void 0) {
-      return `faker.string.alpha({ length: { min: ${min} } })`;
-    }
-    if (max !== void 0) {
-      return `faker.string.alpha({ length: { max: ${max} } })`;
-    }
-    return "faker.string.alpha()";
-  },
-  boolean: () => "faker.datatype.boolean()",
-  undefined: () => "undefined",
-  null: () => "null",
-  array: (items = []) => `faker.helpers.arrayElements([${items.join(", ")}]) as any`,
-  tuple: (items = []) => `faker.helpers.arrayElements([${items.join(", ")}]) as any`,
-  enum: (items = []) => `faker.helpers.arrayElement<any>([${items.join(", ")}])`,
-  union: (items = []) => `faker.helpers.arrayElement<any>([${items.join(", ")}])`,
-  /**
-   * ISO 8601
-   */
-  datetime: () => "faker.date.anytime().toISOString()",
-  /**
-   * Type `'date'` Date
-   * Type `'string'` ISO date format (YYYY-MM-DD)
-   * @default ISO date format (YYYY-MM-DD)
-   */
-  date: (type = "string", parser) => {
-    if (type === "string") {
-      if (parser) {
-        return `${parser}(faker.date.anytime()).format("YYYY-MM-DD")`;
-      }
-      return "faker.date.anytime().toString()";
-    }
-    return "faker.date.anytime()";
-  },
-  /**
-   * Type `'date'` Date
-   * Type `'string'` ISO time format (HH:mm:ss[.SSSSSS])
-   * @default ISO time format (HH:mm:ss[.SSSSSS])
-   */
-  time: (type = "string", parser) => {
-    if (type === "string") {
-      if (parser) {
-        return `${parser}(faker.date.anytime()).format("HH:mm:ss")`;
-      }
-      return "faker.date.anytime().toString()";
-    }
-    return "faker.date.anytime()";
-  },
-  uuid: () => "faker.string.uuid()",
-  url: () => "faker.internet.url()",
-  and: (items = []) => `Object.assign({}, ${items.join(", ")})`,
-  object: () => "object",
-  ref: () => "ref",
-  matches: (value = "", regexGenerator = "faker") => {
-    if (regexGenerator === "randexp") {
-      return `${transformers.toRegExpString(value, "RandExp")}.gen()`;
-    }
-    return `faker.helpers.fromRegExp(${transformers.toRegExpString(value)})`;
-  },
-  email: () => "faker.internet.email()",
-  firstName: () => "faker.person.firstName()",
-  lastName: () => "faker.person.lastName()",
-  password: () => "faker.internet.password()",
-  phone: () => "faker.phone.number()",
-  blob: () => "faker.image.imageUrl() as unknown as Blob",
-  default: void 0,
-  describe: void 0,
-  const: (value) => value ?? "",
-  max: void 0,
-  min: void 0,
-  nullable: void 0,
-  nullish: void 0,
-  optional: void 0,
-  readOnly: void 0,
-  strict: void 0,
-  deprecated: void 0,
-  example: void 0,
-  schema: void 0,
-  catchall: void 0,
-  name: void 0
-};
-function schemaKeywordsorter(a, b) {
-  if (b.keyword === "null") {
-    return -1;
-  }
-  return 0;
-}
-function joinItems(items) {
-  switch (items.length) {
-    case 0:
-      return "undefined";
-    case 1:
-      return items[0];
-    default:
-      return fakerKeywordMapper.union(items);
-  }
-}
-function parse(parent, current, options) {
-  const value = fakerKeywordMapper[current.keyword];
-  if (!value) {
-    return void 0;
-  }
-  if (isKeyword(current, schemaKeywords.union)) {
-    return fakerKeywordMapper.union(current.args.map((schema) => parse(current, schema, { ...options, withData: false })).filter(Boolean));
-  }
-  if (isKeyword(current, schemaKeywords.and)) {
-    return fakerKeywordMapper.and(current.args.map((schema) => parse(current, schema, { ...options, withData: false })).filter(Boolean));
-  }
-  if (isKeyword(current, schemaKeywords.array)) {
-    return fakerKeywordMapper.array(current.args.items.map((schema) => parse(current, schema, { ...options, withData: false })).filter(Boolean));
-  }
-  if (isKeyword(current, schemaKeywords.enum)) {
-    return fakerKeywordMapper.enum(
-      current.args.items.map((schema) => {
-        if (schema.format === "number") {
-          return schema.name;
-        }
-        return transformers.stringify(schema.name);
-      })
-    );
-  }
-  if (isKeyword(current, schemaKeywords.ref)) {
-    if (!current.args?.name) {
-      throw new Error(`Name not defined for keyword ${current.keyword}`);
-    }
-    if (options.withData) {
-      return `${current.args.name}(data)`;
-    }
-    return `${current.args.name}()`;
-  }
-  if (isKeyword(current, schemaKeywords.object)) {
-    const argsObject = Object.entries(current.args?.properties || {}).filter((item) => {
-      const schema = item[1];
-      return schema && typeof schema.map === "function";
-    }).map(([name, schemas]) => {
-      const nameSchema = schemas.find((schema) => schema.keyword === schemaKeywords.name);
-      const mappedName = nameSchema?.args || name;
-      if (options.mapper?.[mappedName]) {
-        return `"${name}": ${options.mapper?.[mappedName]}`;
-      }
-      return `"${name}": ${joinItems(
-        schemas.sort(schemaKeywordsorter).map((schema) => parse(current, schema, { ...options, withData: false })).filter(Boolean)
-      )}`;
-    }).join(",");
-    return `{${argsObject}}`;
-  }
-  if (isKeyword(current, schemaKeywords.tuple)) {
-    if (Array.isArray(current.args.items)) {
-      return fakerKeywordMapper.tuple(current.args.items.map((schema) => parse(current, schema, { ...options, withData: false })).filter(Boolean));
-    }
-    return parse(current, current.args.items, { ...options, withData: false });
-  }
-  if (isKeyword(current, schemaKeywords.const)) {
-    if (current.args.format === "number" && current.args.name !== void 0) {
-      return fakerKeywordMapper.const(current.args.name?.toString());
-    }
-    return fakerKeywordMapper.const(transformers.stringify(current.args.value));
-  }
-  if (isKeyword(current, schemaKeywords.matches) && current.args) {
-    return fakerKeywordMapper.matches(current.args, options.regexGenerator);
-  }
-  if (isKeyword(current, schemaKeywords.null) || isKeyword(current, schemaKeywords.undefined) || isKeyword(current, schemaKeywords.any)) {
-    return value() || "";
-  }
-  if (isKeyword(current, schemaKeywords.string)) {
-    if (parent) {
-      const minSchema = SchemaGenerator.find([parent], schemaKeywords.min);
-      const maxSchema = SchemaGenerator.find([parent], schemaKeywords.max);
-      return fakerKeywordMapper.string(minSchema?.args, maxSchema?.args);
-    }
-    return fakerKeywordMapper.string();
-  }
-  if (isKeyword(current, schemaKeywords.number)) {
-    if (parent) {
-      const minSchema = SchemaGenerator.find([parent], schemaKeywords.min);
-      const maxSchema = SchemaGenerator.find([parent], schemaKeywords.max);
-      return fakerKeywordMapper.number(minSchema?.args, maxSchema?.args);
-    }
-    return fakerKeywordMapper.number();
-  }
-  if (isKeyword(current, schemaKeywords.integer)) {
-    if (parent) {
-      const minSchema = SchemaGenerator.find([parent], schemaKeywords.min);
-      const maxSchema = SchemaGenerator.find([parent], schemaKeywords.max);
-      return fakerKeywordMapper.integer(minSchema?.args, maxSchema?.args);
-    }
-    return fakerKeywordMapper.integer();
-  }
-  if (isKeyword(current, schemaKeywords.datetime)) {
-    return fakerKeywordMapper.datetime();
-  }
-  if (isKeyword(current, schemaKeywords.date)) {
-    return fakerKeywordMapper.date(current.args.type, options.dateParser);
-  }
-  if (isKeyword(current, schemaKeywords.time)) {
-    return fakerKeywordMapper.time(current.args.type, options.dateParser);
-  }
-  if (current.keyword in fakerKeywordMapper && "args" in current) {
-    const value2 = fakerKeywordMapper[current.keyword];
-    const options2 = JSON.stringify(current.args);
-    return value2(options2);
-  }
-  if (current.keyword in fakerKeywordMapper) {
-    return value();
-  }
-  return void 0;
-}
-var OperationGenerator = class extends OperationGenerator$1 {
-  async operation(operation, options) {
-    const { oas, pluginManager, plugin, mode } = this.context;
-    const root = createRoot({
-      logger: pluginManager.logger
-    });
-    root.render(
-      /* @__PURE__ */ jsx(App, { pluginManager, plugin: { ...plugin, options }, mode, children: /* @__PURE__ */ jsx(Oas, { oas, operations: [operation], generator: this, children: /* @__PURE__ */ jsx(Oas.Operation, { operation, children: /* @__PURE__ */ jsx(OperationSchema.File, {}) }) }) })
-    );
-    return root.files;
-  }
-};
-
-// src/plugin.ts
-var pluginFakerName = "plugin-faker";
-createPlugin((options) => {
-  const {
-    output = { path: "mocks" },
-    seed,
-    group,
-    exclude = [],
-    include,
-    override = [],
-    transformers: transformers3 = {},
-    mapper = {},
-    dateType = "string",
-    unknownType = "any",
-    dateParser,
-    regexGenerator = "faker"
-  } = options;
-  const template = group?.output ? group.output : `${output.path}/{{tag}}Controller`;
-  return {
-    name: pluginFakerName,
-    output: {
-      exportType: "barrelNamed",
-      ...output
-    },
-    options: {
-      extName: output.extName,
-      transformers: transformers3,
-      dateType,
-      seed,
-      unknownType,
-      dateParser,
-      mapper,
-      override,
-      regexGenerator
-    },
-    pre: [pluginOasName, pluginTsName],
-    resolvePath(baseName, pathMode, options2) {
-      const root = path.resolve(this.config.root, this.config.output.path);
-      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path));
-      if (mode === "single") {
-        return path.resolve(root, output.path);
-      }
-      if (options2?.tag && group?.type === "tag") {
-        const tag = camelCase(options2.tag);
-        return path.resolve(root, renderTemplate(template, { tag }), baseName);
-      }
-      return path.resolve(root, output.path, baseName);
-    },
-    resolveName(name, type) {
-      const resolvedName = camelCase(name, {
-        prefix: type ? "create" : void 0,
-        isFile: type === "file"
-      });
-      if (type) {
-        return transformers3?.name?.(resolvedName, type) || resolvedName;
-      }
-      return resolvedName;
-    },
-    async buildStart() {
-      const [swaggerPlugin] = PluginManager.getDependedPlugins(this.plugins, [pluginOasName]);
-      const oas = await swaggerPlugin.context.getOas();
-      const root = path.resolve(this.config.root, this.config.output.path);
-      const mode = FileManager.getMode(path.resolve(root, output.path));
-      const schemaGenerator = new SchemaGenerator2(this.plugin.options, {
-        oas,
-        pluginManager: this.pluginManager,
-        plugin: this.plugin,
-        contentType: swaggerPlugin.context.contentType,
-        include: void 0,
-        override,
-        mode,
-        output: output.path
-      });
-      const schemaFiles = await schemaGenerator.build();
-      await this.addFile(...schemaFiles);
-      const operationGenerator = new OperationGenerator(this.plugin.options, {
-        oas,
-        pluginManager: this.pluginManager,
-        plugin: this.plugin,
-        contentType: swaggerPlugin.context.contentType,
-        exclude,
-        include,
-        override,
-        mode
-      });
-      const operationFiles = await operationGenerator.build();
-      await this.addFile(...operationFiles);
-      if (this.config.output.exportType) {
-        const barrelFiles = await this.fileManager.getBarrelFiles({
-          root,
-          output,
-          files: this.fileManager.files,
-          meta: {
-            pluginKey: this.plugin.key
-          },
-          logger: this.logger
-        });
-        await this.addFile(...barrelFiles);
-      }
-    }
-  };
-});
-function Schema(props) {
-  const { withData, description } = props;
-  const { tree, name } = useSchema();
-  const {
-    pluginManager,
-    plugin: {
-      options: { dateParser, regexGenerator, mapper, seed }
-    }
-  } = useApp();
-  const resolvedName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginFakerName],
-    type: "function"
-  });
-  const typeName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginTsName],
-    type: "type"
-  });
-  const fakerText = joinItems(
-    tree.map((schema) => parse(void 0, schema, { name: resolvedName, typeName, seed, regexGenerator, mapper, withData, dateParser })).filter(Boolean)
-  );
-  let fakerDefaultOverride = void 0;
-  let fakerTextWithOverride = fakerText;
-  if (withData && fakerText.startsWith("{")) {
-    fakerDefaultOverride = "{}";
-    fakerTextWithOverride = `{
-  ...${fakerText},
-  ...data
-}`;
-  }
-  if (withData && fakerText.startsWith("faker.helpers.arrayElements")) {
-    fakerDefaultOverride = "[]";
-    fakerTextWithOverride = `[
-      ...${fakerText},
-      ...data
-    ]`;
-  }
-  const params = fakerDefaultOverride ? `data: NonNullable<Partial<${typeName}>> = ${fakerDefaultOverride}` : `data?: NonNullable<Partial<${typeName}>>`;
-  const containsFaker = !!fakerTextWithOverride.match(/faker/) || !!seed;
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    containsFaker && /* @__PURE__ */ jsx(File.Import, { name: ["faker"], path: "@faker-js/faker" }),
-    /* @__PURE__ */ jsxs(File.Source, { name: resolvedName, isExportable: true, isIndexable: true, children: [
-      /* @__PURE__ */ jsxs(
-        Function,
-        {
-          export: true,
-          name: resolvedName,
-          JSDoc: { comments: [description ? `@description ${transformers.jsStringEscape(description)}` : void 0].filter(Boolean) },
-          params: withData ? params : "",
-          returnType: typeName ? `NonNullable<${typeName}>` : "",
-          children: [
-            seed ? `faker.seed(${JSON.stringify(seed)})` : "",
-            /* @__PURE__ */ jsx("br", {}),
-            /* @__PURE__ */ jsx(Function.Return, { children: fakerTextWithOverride })
-          ]
-        }
-      ),
-      /* @__PURE__ */ jsx("br", {})
-    ] })
-  ] });
-}
-Schema.File = function({}) {
-  const { pluginManager } = useApp();
-  const { tree, schema } = useSchema();
-  const withData = tree.some(
-    (schema2) => schema2.keyword === schemaKeywords.array || schema2.keyword === schemaKeywords.and || schema2.keyword === schemaKeywords.object || schema2.keyword === schemaKeywords.union || schema2.keyword === schemaKeywords.tuple
-  );
-  return /* @__PURE__ */ jsxs(Oas.Schema.File, { output: pluginManager.config.output.path, children: [
-    /* @__PURE__ */ jsx(Schema.Imports, {}),
-    /* @__PURE__ */ jsx(Schema, { description: schema?.description, withData })
-  ] });
-};
-Schema.Imports = () => {
-  const {
-    pluginManager,
-    plugin: {
-      options: { extName, dateParser, regexGenerator }
-    }
-  } = useApp();
-  const { path: root } = useFile();
-  const { name, tree, schema } = useSchema();
-  const typeName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginTsName],
-    type: "type"
-  });
-  const typeFileName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginTsName],
-    type: "file"
-  });
-  const typePath = pluginManager.resolvePath({
-    baseName: typeFileName,
-    pluginKey: [pluginTsName]
-  });
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    regexGenerator === "randexp" && /* @__PURE__ */ jsx(File.Import, { name: "RandExp", path: "randexp" }),
-    dateParser && /* @__PURE__ */ jsx(File.Import, { path: dateParser, name: dateParser }),
-    typeName && typePath && /* @__PURE__ */ jsx(File.Import, { isTypeOnly: true, root, path: typePath, name: [typeName] })
-  ] });
-};
-var SchemaGenerator2 = class extends SchemaGenerator {
-  async schema(name, schema, options) {
-    const { oas, pluginManager, plugin, mode, output } = this.context;
-    const root = createRoot({
-      logger: pluginManager.logger
-    });
-    const tree = this.parse({ schema, name });
-    root.render(
-      /* @__PURE__ */ jsx(App, { pluginManager, plugin: { ...plugin, options }, mode, children: /* @__PURE__ */ jsx(Oas, { oas, children: /* @__PURE__ */ jsx(Oas.Schema, { name, value: schema, tree, children: /* @__PURE__ */ jsx(Schema.File, {}) }) }) })
-    );
-    return root.files;
-  }
-};
-function OperationSchema({ description }) {
-  return /* @__PURE__ */ jsx(Schema, { withData: false, description });
-}
-OperationSchema.File = function({}) {
-  const { plugin, pluginManager, mode } = useApp();
-  const oas = useOas();
-  const { getSchemas, getFile } = useOperationManager();
-  const operation = useOperation();
-  const file = getFile(operation);
-  const schemas = getSchemas(operation);
-  const generator = new SchemaGenerator2(plugin.options, {
-    oas,
-    plugin,
-    pluginManager,
-    mode,
-    override: plugin.options.override
-  });
-  const items = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response].flat().filter(Boolean);
-  const mapItem = ({ name, schema, description, ...options }, i) => {
-    const typeName = pluginManager.resolveName({
-      name,
-      pluginKey: [pluginTsName],
-      type: "type"
-    });
-    const typeFileName = pluginManager.resolveName({
-      name: options.operationName || name,
-      pluginKey: [pluginTsName],
-      type: "file"
-    });
-    const typePath = pluginManager.resolvePath({
-      baseName: typeFileName,
-      pluginKey: [pluginTsName],
-      options: { tag: options.operation?.getTags()[0]?.name }
-    });
-    const tree = generator.parse({ schema, name });
-    return /* @__PURE__ */ jsxs(Oas.Schema, { name, value: schema, tree, children: [
-      typeName && typePath && /* @__PURE__ */ jsx(File.Import, { isTypeOnly: true, root: file.path, path: typePath, name: [typeName] }),
-      plugin.options.dateParser && /* @__PURE__ */ jsx(File.Import, { path: plugin.options.dateParser, name: plugin.options.dateParser }),
-      mode === "split" && /* @__PURE__ */ jsx(Oas.Schema.Imports, {}),
-      /* @__PURE__ */ jsx(OperationSchema, { description })
-    ] }, i);
-  };
-  return /* @__PURE__ */ jsxs(File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
-    plugin.options.regexGenerator === "randexp" && /* @__PURE__ */ jsx(File.Import, { name: "RandExp", path: "randexp" }),
-    items.map(mapItem)
-  ] });
-};
-
-export { OperationSchema, Schema };
+export { Faker } from './chunk-Q5K4KJXX.js';
 //# sourceMappingURL=components.js.map
 //# sourceMappingURL=components.js.map