@naturalcycles/js-lib 15.46.0 → 15.47.0

package/dist/json-schema/jsonSchemaBuilder.d.ts

@@ -1,159 +0,0 @@
-import { type AnyObject, type BaseDBEntity, type IsoDate, type IsoDateTime, type NumberEnum, type StringEnum, type UnixTimestamp, type UnixTimestampMillis } from '../types.js';
-import type { JsonSchema, JsonSchemaAllOf, JsonSchemaAny, JsonSchemaArray, JsonSchemaBoolean, JsonSchemaConst, JsonSchemaEnum, JsonSchemaNull, JsonSchemaNumber, JsonSchemaObject, JsonSchemaOneOf, JsonSchemaRef, JsonSchemaString, JsonSchemaTuple } from './jsonSchema.model.js';
-export interface JsonSchemaBuilder<T = unknown> {
-    build: () => JsonSchema<T>;
-}
-/**
- * Fluent (chainable) API to manually create Json Schemas.
- * Inspired by Joi and Zod.
- */
-export declare const j: {
-    any<T = unknown>(): JsonSchemaAnyBuilder<T, JsonSchemaAny<T>, false>;
-    const<T extends string | number | boolean | null>(value: T): JsonSchemaAnyBuilder<T, JsonSchemaConst<T>, false>;
-    null(): JsonSchemaAnyBuilder<null, JsonSchemaNull, false>;
-    ref<T = unknown>($ref: string): JsonSchemaAnyBuilder<T, JsonSchemaRef<T>, false>;
-    enum<const T extends readonly (string | number | boolean | null)[] | StringEnum | NumberEnum>(input: T): JsonSchemaAnyBuilder<T extends readonly (infer U)[] ? U : T extends StringEnum ? T[keyof T] : T extends NumberEnum ? T[keyof T] : never, JsonSchemaEnum<any>, false>;
-    boolean(): JsonSchemaAnyBuilder<boolean, JsonSchemaBoolean, false>;
-    buffer(): JsonSchemaAnyBuilder<Buffer<ArrayBufferLike>, JsonSchemaAny<Buffer<ArrayBufferLike>>, false>;
-    number<T extends number = number>(): JsonSchemaNumberBuilder<T, false>;
-    integer<T extends number = number>(): JsonSchemaNumberBuilder<T, false>;
-    string<T extends string = string>(): JsonSchemaStringBuilder<T, false>;
-    object: typeof object;
-    dbEntity<P extends Record<string, JsonSchemaAnyBuilder<any, any, any>>>(props: P): JsonSchemaObjectBuilder<BaseDBEntity & { [K in keyof P]: P[K] extends JsonSchemaAnyBuilder<infer U, any, any> ? U : never; }>;
-    rootObject<T extends AnyObject>(props: { [K in keyof T]: JsonSchemaAnyBuilder<T[K]>; }): JsonSchemaObjectBuilder<T, false>;
-    array<T extends JsonSchemaAnyBuilder<any>>(itemSchema: T): JsonSchemaArrayBuilder<T["infer"], false>;
-    tuple<T extends any[] = unknown[]>(items: JsonSchemaAnyBuilder[]): JsonSchemaTupleBuilder<T>;
-    oneOf<Builders extends JsonSchemaAnyBuilder<any, any, any>[]>(items: [...Builders]): JsonSchemaAnyBuilder<Builders[number] extends JsonSchemaAnyBuilder<infer U, any, any> ? U : never, JsonSchemaOneOf<Builders[number] extends JsonSchemaAnyBuilder<infer U, any, any> ? U : never>>;
-    allOf<T = unknown>(items: JsonSchemaAnyBuilder[]): JsonSchemaAnyBuilder<T, JsonSchemaAllOf<T>, false>;
-};
-export declare class JsonSchemaAnyBuilder<T = unknown, SCHEMA_TYPE extends JsonSchema<T> = JsonSchema<T>, Opt extends boolean = false> implements JsonSchemaBuilder<T> {
-    protected schema: SCHEMA_TYPE;
-    constructor(schema: SCHEMA_TYPE);
-    /**
-     * Used in ObjectBuilder to access schema.optionalProperty
-     */
-    getSchema(): SCHEMA_TYPE;
-    $schema($schema: string): this;
-    $schemaDraft7(): this;
-    $id($id: string): this;
-    title(title: string): this;
-    description(description: string): this;
-    deprecated(deprecated?: boolean): this;
-    type(type: string): this;
-    default(v: any): this;
-    instanceof(of: string): this;
-    optional(): JsonSchemaAnyBuilder<T | undefined, JsonSchema<T | undefined>, true>;
-    optional(optional: true): JsonSchemaAnyBuilder<T | undefined, JsonSchema<T | undefined>, true>;
-    optional(optional: false): JsonSchemaAnyBuilder<Exclude<T, undefined>, JsonSchema<Exclude<T, undefined>>, false>;
-    nullable(): JsonSchemaAnyBuilder<T | null, JsonSchema<T | null>, Opt>;
-    /**
-     * Produces a "clean schema object" without methods.
-     * Same as if it would be JSON.stringified.
-     */
-    build(): SCHEMA_TYPE;
-    clone(): JsonSchemaAnyBuilder<T, SCHEMA_TYPE, Opt>;
-    /**
-     * @experimental
-     */
-    infer: T;
-}
-export declare class JsonSchemaNumberBuilder<T extends number = number, Opt extends boolean = false> extends JsonSchemaAnyBuilder<T, JsonSchemaNumber<T>, Opt> {
-    constructor();
-    integer(): this;
-    multipleOf(multipleOf: number): this;
-    min(minimum: number): this;
-    exclusiveMin(exclusiveMinimum: number): this;
-    max(maximum: number): this;
-    exclusiveMax(exclusiveMaximum: number): this;
-    /**
-     * Both ranges are inclusive.
-     */
-    range(minimum: number, maximum: number): this;
-    format(format: string): this;
-    int32: () => this;
-    int64: () => this;
-    float: () => this;
-    double: () => this;
-    unixTimestamp: () => JsonSchemaNumberBuilder<UnixTimestamp>;
-    unixTimestamp2000: () => JsonSchemaNumberBuilder<UnixTimestamp>;
-    unixTimestampMillis: () => JsonSchemaNumberBuilder<UnixTimestampMillis>;
-    unixTimestampMillis2000: () => JsonSchemaNumberBuilder<UnixTimestampMillis>;
-    utcOffset: () => this;
-    utcOffsetHours: () => this;
-    branded<B extends number>(): JsonSchemaNumberBuilder<B>;
-}
-export declare class JsonSchemaStringBuilder<T extends string = string, Opt extends boolean = false> extends JsonSchemaAnyBuilder<T, JsonSchemaString<T>, Opt> {
-    constructor();
-    regex(pattern: RegExp): this;
-    pattern(pattern: string): this;
-    min(minLength: number): this;
-    max(maxLength: number): this;
-    length(minLength: number, maxLength: number): this;
-    format(format: string): this;
-    email: () => this;
-    url: () => this;
-    ipv4: () => this;
-    ipv6: () => this;
-    password: () => this;
-    id: () => this;
-    slug: () => this;
-    semVer: () => this;
-    languageTag: () => this;
-    countryCode: () => this;
-    currency: () => this;
-    trim(trim?: boolean): this;
-    toLowerCase(toLowerCase?: boolean): this;
-    toUpperCase(toUpperCase?: boolean): this;
-    truncate(toLength: number): this;
-    branded<B extends string>(): JsonSchemaStringBuilder<B>;
-    /**
-     * Accepts only the `YYYY-MM-DD` shape from all ISO 8601 variants.
-     */
-    isoDate(): JsonSchemaStringBuilder<IsoDate>;
-    /**
-     * Accepts strings that start with the `YYYY-MM-DDTHH:MM:SS` shape
-     * and optionally end with either a `Z` or a `+/-hh:mm` timezone part.
-     */
-    isoDateTime(): JsonSchemaStringBuilder<IsoDateTime>;
-    jwt(): this;
-}
-export declare class JsonSchemaObjectBuilder<T extends AnyObject, Opt extends boolean = false> extends JsonSchemaAnyBuilder<T, JsonSchemaObject<T>, Opt> {
-    constructor();
-    addProperties(props?: {
-        [k in keyof T]: JsonSchemaBuilder<T[k]>;
-    }): this;
-    /**
-     * Ensures `required` is always sorted and _uniq
-     */
-    required(required: (keyof T)[]): this;
-    addRequired(required: (keyof T)[]): this;
-    minProps(minProperties: number): this;
-    maxProps(maxProperties: number): this;
-    additionalProps(additionalProperties: boolean): this;
-    baseDBEntity(): JsonSchemaObjectBuilder<T & BaseDBEntity>;
-    extend<T2 extends AnyObject>(s2: JsonSchemaObjectBuilder<T2>): JsonSchemaObjectBuilder<T & T2 extends infer O ? {
-        [K in keyof O]: O[K];
-    } : never>;
-}
-export declare class JsonSchemaArrayBuilder<ITEM, Opt extends boolean = false> extends JsonSchemaAnyBuilder<ITEM[], JsonSchemaArray<ITEM>, Opt> {
-    constructor(itemsSchema: JsonSchemaBuilder<ITEM>);
-    min(minItems: number): this;
-    max(maxItems: number): this;
-    unique(uniqueItems?: boolean): this;
-}
-export declare class JsonSchemaTupleBuilder<T extends any[]> extends JsonSchemaAnyBuilder<T, JsonSchemaTuple<T>> {
-    constructor(items: JsonSchemaBuilder[]);
-}
-declare function object<P extends Record<string, JsonSchemaAnyBuilder<any, any, any>>>(props?: {
-    [K in keyof P]: P[K] & JsonSchemaAnyBuilder<any, any, any>;
-}): JsonSchemaObjectBuilder<{
-    [K in keyof P as P[K] extends JsonSchemaAnyBuilder<any, any, infer Opt> ? Opt extends true ? never : K : never]: P[K] extends JsonSchemaAnyBuilder<infer U, any, any> ? U : never;
-} & {
-    [K in keyof P as P[K] extends JsonSchemaAnyBuilder<any, any, infer Opt> ? Opt extends true ? K : never : never]?: P[K] extends JsonSchemaAnyBuilder<infer U, any, any> ? U : never;
-} extends infer O ? {
-    [K in keyof O]: O[K];
-} : never>;
-declare function object<T extends AnyObject>(props?: {
-    [K in keyof T]: JsonSchemaAnyBuilder<T[K]>;
-}): JsonSchemaObjectBuilder<T>;
-export {};

package/dist/json-schema/jsonSchemaBuilder.js

@@ -1,412 +0,0 @@
-import { _uniq } from '../array/array.util.js';
-import { _numberEnumValues, _stringEnumValues, getEnumType } from '../enum.util.js';
-import { _assert } from '../error/assert.js';
-import { _deepCopy } from '../object/object.util.js';
-import { _sortObject } from '../object/sortObject.js';
-import { JWT_REGEX, } from '../types.js';
-import { JSON_SCHEMA_ORDER } from './jsonSchema.cnst.js';
-import { mergeJsonSchemaObjects } from './jsonSchema.util.js';
-/**
- * Fluent (chainable) API to manually create Json Schemas.
- * Inspired by Joi and Zod.
- */
-export const j = {
-    any() {
-        return new JsonSchemaAnyBuilder({});
-    },
-    const(value) {
-        return new JsonSchemaAnyBuilder({
-            const: value,
-        });
-    },
-    null() {
-        return new JsonSchemaAnyBuilder({
-            type: 'null',
-        });
-    },
-    ref($ref) {
-        return new JsonSchemaAnyBuilder({
-            $ref,
-        });
-    },
-    enum(input) {
-        let enumValues;
-        if (Array.isArray(input)) {
-            enumValues = input;
-        }
-        else if (typeof input === 'object') {
-            const enumType = getEnumType(input);
-            if (enumType === 'NumberEnum') {
-                enumValues = _numberEnumValues(input);
-            }
-            else if (enumType === 'StringEnum') {
-                enumValues = _stringEnumValues(input);
-            }
-        }
-        _assert(enumValues, 'Unsupported enum input');
-        return new JsonSchemaAnyBuilder({
-            enum: enumValues,
-        });
-    },
-    boolean() {
-        return new JsonSchemaAnyBuilder({
-            type: 'boolean',
-        });
-    },
-    buffer() {
-        return new JsonSchemaAnyBuilder({ instanceof: 'Buffer' });
-    },
-    // number types
-    number() {
-        return new JsonSchemaNumberBuilder();
-    },
-    integer() {
-        return new JsonSchemaNumberBuilder().integer();
-    },
-    // string types
-    string() {
-        return new JsonSchemaStringBuilder();
-    },
-    // complex types
-    object,
-    dbEntity(props) {
-        return j
-            .object({
-            id: j.string(),
-            created: j.integer().unixTimestamp2000(),
-            updated: j.integer().unixTimestamp2000(),
-        })
-            .extend(j.object(props));
-    },
-    rootObject(props) {
-        return new JsonSchemaObjectBuilder().addProperties(props).$schemaDraft7();
-    },
-    array(itemSchema) {
-        return new JsonSchemaArrayBuilder(itemSchema);
-    },
-    tuple(items) {
-        return new JsonSchemaTupleBuilder(items);
-    },
-    oneOf(items) {
-        return new JsonSchemaAnyBuilder({
-            oneOf: items.map(b => b.build()),
-        });
-    },
-    allOf(items) {
-        return new JsonSchemaAnyBuilder({
-            allOf: items.map(b => b.build()),
-        });
-    },
-};
-export class JsonSchemaAnyBuilder {
-    schema;
-    constructor(schema) {
-        this.schema = schema;
-    }
-    /**
-     * Used in ObjectBuilder to access schema.optionalProperty
-     */
-    getSchema() {
-        return this.schema;
-    }
-    $schema($schema) {
-        Object.assign(this.schema, { $schema });
-        return this;
-    }
-    $schemaDraft7() {
-        this.$schema('http://json-schema.org/draft-07/schema#');
-        return this;
-    }
-    $id($id) {
-        Object.assign(this.schema, { $id });
-        return this;
-    }
-    title(title) {
-        Object.assign(this.schema, { title });
-        return this;
-    }
-    description(description) {
-        Object.assign(this.schema, { description });
-        return this;
-    }
-    deprecated(deprecated = true) {
-        Object.assign(this.schema, { deprecated });
-        return this;
-    }
-    type(type) {
-        Object.assign(this.schema, { type });
-        return this;
-    }
-    default(v) {
-        Object.assign(this.schema, { default: v });
-        return this;
-    }
-    instanceof(of) {
-        Object.assign(this.schema, { type: 'object', instanceof: of });
-        return this;
-    }
-    optional(optional = true) {
-        if (optional) {
-            this.schema.optionalField = true;
-        }
-        else {
-            this.schema.optionalField = undefined;
-        }
-        return this;
-    }
-    nullable() {
-        return new JsonSchemaAnyBuilder({
-            anyOf: [this.build(), { type: 'null' }],
-        });
-    }
-    /**
-     * Produces a "clean schema object" without methods.
-     * Same as if it would be JSON.stringified.
-     */
-    build() {
-        return _sortObject(JSON.parse(JSON.stringify(this.schema)), JSON_SCHEMA_ORDER);
-    }
-    clone() {
-        return new JsonSchemaAnyBuilder(_deepCopy(this.schema));
-    }
-    /**
-     * @experimental
-     */
-    infer;
-}
-export class JsonSchemaNumberBuilder extends JsonSchemaAnyBuilder {
-    constructor() {
-        super({
-            type: 'number',
-        });
-    }
-    integer() {
-        Object.assign(this.schema, { type: 'integer' });
-        return this;
-    }
-    multipleOf(multipleOf) {
-        Object.assign(this.schema, { multipleOf });
-        return this;
-    }
-    min(minimum) {
-        Object.assign(this.schema, { minimum });
-        return this;
-    }
-    exclusiveMin(exclusiveMinimum) {
-        Object.assign(this.schema, { exclusiveMinimum });
-        return this;
-    }
-    max(maximum) {
-        Object.assign(this.schema, { maximum });
-        return this;
-    }
-    exclusiveMax(exclusiveMaximum) {
-        Object.assign(this.schema, { exclusiveMaximum });
-        return this;
-    }
-    /**
-     * Both ranges are inclusive.
-     */
-    range(minimum, maximum) {
-        Object.assign(this.schema, { minimum, maximum });
-        return this;
-    }
-    format(format) {
-        Object.assign(this.schema, { format });
-        return this;
-    }
-    int32 = () => this.format('int32');
-    int64 = () => this.format('int64');
-    float = () => this.format('float');
-    double = () => this.format('double');
-    unixTimestamp = () => this.integer().branded().format('unixTimestamp').description('UnixTimestamp');
-    unixTimestamp2000 = () => this.integer()
-        .branded()
-        .format('unixTimestamp2000')
-        .description('UnixTimestamp2000');
-    unixTimestampMillis = () => this.integer()
-        .branded()
-        .format('unixTimestampMillis')
-        .description('UnixTimestampMillis');
-    unixTimestampMillis2000 = () => this.integer()
-        .branded()
-        .format('unixTimestampMillis2000')
-        .description('UnixTimestampMillis2000');
-    utcOffset = () => this.format('utcOffset');
-    utcOffsetHours = () => this.format('utcOffsetHours');
-    branded() {
-        return this;
-    }
-}
-export class JsonSchemaStringBuilder extends JsonSchemaAnyBuilder {
-    constructor() {
-        super({
-            type: 'string',
-        });
-    }
-    regex(pattern) {
-        return this.pattern(pattern.source);
-    }
-    pattern(pattern) {
-        Object.assign(this.schema, { pattern });
-        return this;
-    }
-    min(minLength) {
-        Object.assign(this.schema, { minLength });
-        return this;
-    }
-    max(maxLength) {
-        Object.assign(this.schema, { maxLength });
-        return this;
-    }
-    length(minLength, maxLength) {
-        Object.assign(this.schema, { minLength, maxLength });
-        return this;
-    }
-    format(format) {
-        Object.assign(this.schema, { format });
-        return this;
-    }
-    email = () => this.format('email');
-    url = () => this.format('url');
-    ipv4 = () => this.format('ipv4');
-    ipv6 = () => this.format('ipv6');
-    password = () => this.format('password');
-    id = () => this.format('id');
-    slug = () => this.format('slug');
-    semVer = () => this.format('semVer');
-    languageTag = () => this.format('languageTag');
-    countryCode = () => this.format('countryCode');
-    currency = () => this.format('currency');
-    trim(trim = true) {
-        Object.assign(this.schema, { transform: { ...this.schema.transform, trim } });
-        return this;
-    }
-    toLowerCase(toLowerCase = true) {
-        Object.assign(this.schema, { transform: { ...this.schema.transform, toLowerCase } });
-        return this;
-    }
-    toUpperCase(toUpperCase = true) {
-        Object.assign(this.schema, { transform: { ...this.schema.transform, toUpperCase } });
-        return this;
-    }
-    truncate(toLength) {
-        Object.assign(this.schema, { transform: { ...this.schema.transform, truncate: toLength } });
-        return this;
-    }
-    branded() {
-        return this;
-    }
-    /**
-     * Accepts only the `YYYY-MM-DD` shape from all ISO 8601 variants.
-     */
-    isoDate() {
-        return this.format('IsoDate').branded().description('IsoDate');
-    }
-    /**
-     * Accepts strings that start with the `YYYY-MM-DDTHH:MM:SS` shape
-     * and optionally end with either a `Z` or a `+/-hh:mm` timezone part.
-     */
-    isoDateTime() {
-        return this.format('IsoDateTime').branded().description('IsoDateTime');
-    }
-    jwt() {
-        return this.regex(JWT_REGEX);
-    }
-}
-export class JsonSchemaObjectBuilder extends JsonSchemaAnyBuilder {
-    constructor() {
-        super({
-            type: 'object',
-            properties: {},
-            required: [],
-            additionalProperties: false,
-        });
-    }
-    addProperties(props) {
-        if (!props)
-            return this;
-        Object.entries(props).forEach(([k, builder]) => {
-            const schema = builder.build();
-            if (!schema.optionalField) {
-                this.schema.required.push(k);
-            }
-            else {
-                schema.optionalField = undefined;
-            }
-            this.schema.properties[k] = schema;
-        });
-        this.required(this.schema.required); // ensure it's sorted and _uniq
-        return this;
-    }
-    /**
-     * Ensures `required` is always sorted and _uniq
-     */
-    required(required) {
-        Object.assign(this.schema, { required });
-        this.schema.required = _uniq(required).sort();
-        return this;
-    }
-    addRequired(required) {
-        return this.required([...this.schema.required, ...required]);
-    }
-    minProps(minProperties) {
-        Object.assign(this.schema, { minProperties });
-        return this;
-    }
-    maxProps(maxProperties) {
-        Object.assign(this.schema, { maxProperties });
-        return this;
-    }
-    additionalProps(additionalProperties) {
-        Object.assign(this.schema, { additionalProperties });
-        return this;
-    }
-    baseDBEntity() {
-        Object.assign(this.schema.properties, {
-            id: { type: 'string' },
-            created: { type: 'number', format: 'unixTimestamp2000' },
-            updated: { type: 'number', format: 'unixTimestamp2000' },
-        });
-        return this.addRequired(['id', 'created', 'updated']);
-    }
-    extend(s2) {
-        const builder = new JsonSchemaObjectBuilder();
-        Object.assign(builder.schema, _deepCopy(this.schema));
-        mergeJsonSchemaObjects(builder.schema, s2.schema);
-        return builder;
-    }
-}
-export class JsonSchemaArrayBuilder extends JsonSchemaAnyBuilder {
-    constructor(itemsSchema) {
-        super({
-            type: 'array',
-            items: itemsSchema.build(),
-        });
-    }
-    min(minItems) {
-        Object.assign(this.schema, { minItems });
-        return this;
-    }
-    max(maxItems) {
-        Object.assign(this.schema, { maxItems });
-        return this;
-    }
-    unique(uniqueItems = true) {
-        Object.assign(this.schema, { uniqueItems });
-        return this;
-    }
-}
-export class JsonSchemaTupleBuilder extends JsonSchemaAnyBuilder {
-    constructor(items) {
-        super({
-            type: 'array',
-            items: items.map(b => b.build()),
-            minItems: items.length,
-            maxItems: items.length,
-        });
-    }
-}
-function object(props) {
-    return new JsonSchemaObjectBuilder().addProperties(props);
-}

package/dist/json-schema/jsonSchemas.d.ts

@@ -1,2 +0,0 @@
-import type { BaseDBEntity } from '../types.js';
-export declare const baseDBEntityJsonSchema: import("./jsonSchemaBuilder.js").JsonSchemaObjectBuilder<BaseDBEntity, false>;

package/dist/json-schema/jsonSchemas.js

@@ -1,6 +0,0 @@
-import { j } from './jsonSchemaBuilder.js';
-export const baseDBEntityJsonSchema = j.object({
-    id: j.string(),
-    created: j.integer().unixTimestamp2000(),
-    updated: j.integer().unixTimestamp2000(),
-});

package/src/json-schema/from-data/generateJsonSchemaFromData.ts

@@ -1,121 +0,0 @@
-import { _uniq } from '../../array/index.js'
-import { _stringMapEntries, type AnyObject, type StringMap } from '../../types.js'
-import type {
-  JsonSchema,
-  JsonSchemaArray,
-  JsonSchemaBoolean,
-  JsonSchemaNull,
-  JsonSchemaNumber,
-  JsonSchemaObject,
-  JsonSchemaOneOf,
-  JsonSchemaString,
-} from '../index.js'
-
-type PrimitiveType = 'undefined' | 'null' | 'boolean' | 'string' | 'number'
-type Type = PrimitiveType | 'array' | 'object'
-
-/**
- * Each row must be an object (current limitation).
- *
- * `additionalProperties` is set to `true`, cause it's safer.
- */
-export function generateJsonSchemaFromData<T extends AnyObject = AnyObject>(
-  rows: AnyObject[],
-): JsonSchemaObject<T> {
-  return objectToJsonSchema(rows as any) as JsonSchemaObject<T>
-}
-
-function objectToJsonSchema(rows: AnyObject[]): JsonSchemaObject {
-  const typesByKey: StringMap<Set<Type>> = {}
-
-  rows.forEach(r => {
-    Object.keys(r).forEach(key => {
-      typesByKey[key] ||= new Set<Type>()
-      typesByKey[key].add(getTypeOfValue(r[key]))
-    })
-  })
-
-  const s: JsonSchemaObject = {
-    type: 'object',
-    properties: {},
-    required: [],
-    additionalProperties: true,
-  }
-
-  _stringMapEntries(typesByKey).forEach(([key, types]) => {
-    const schema = mergeTypes(
-      [...types],
-      rows.map(r => r[key]),
-    )
-    if (!schema) return
-    s.properties[key] = schema
-  })
-
-  // console.log(typesByKey)
-
-  return s
-}
-
-function mergeTypes(types: Type[], samples: any[]): JsonSchema | undefined {
-  // skip "undefined" types
-  types = types.filter(t => t !== 'undefined')
-
-  if (!types.length) return undefined
-
-  if (types.length > 1) {
-    // oneOf
-    const s: JsonSchemaOneOf = {
-      oneOf: types.map(type => mergeTypes([type], samples)!),
-    }
-
-    return s
-  }
-
-  const type = types[0]!
-
-  if (type === 'null') {
-    return {
-      type: 'null',
-    } as JsonSchemaNull
-  }
-
-  if (type === 'boolean') {
-    return {
-      type: 'boolean',
-    } as JsonSchemaBoolean
-  }
-
-  if (type === 'string') {
-    return {
-      type: 'string',
-    } as JsonSchemaString
-  }
-
-  if (type === 'number') {
-    return {
-      type: 'number',
-    } as JsonSchemaNumber
-  }
-
-  if (type === 'object') {
-    return objectToJsonSchema(samples.filter((r: any) => r && typeof r === 'object'))
-  }
-
-  if (type === 'array') {
-    // possible feature: detect if it's a tuple
-    // currently assume no-tuple
-    const items = samples.filter(r => Array.isArray(r)).flat()
-    const itemTypes = _uniq(items.map(i => getTypeOfValue(i)))
-
-    return {
-      type: 'array',
-      items: mergeTypes(itemTypes, items),
-    } as JsonSchemaArray
-  }
-}
-
-function getTypeOfValue(v: any): Type {
-  if (v === null) return 'null'
-  if (Array.isArray(v)) return 'array'
-  return typeof v as Type
-}