@jsonjoy.com/json-type/lib/random/generators.js

High-performance JSON Pointer implementation

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.tup = exports.str = exports.ref = exports.or = exports.obj = exports.num = exports.map = exports.fn = exports.const_ = exports.bool = exports.bin = exports.arr = exports.any = void 0;
const json_random_1 = require("@jsonjoy.com/util/lib/json-random");
const json_clone_1 = require("@jsonjoy.com/util/lib/json-clone");
const any = (type) => {
    return json_random_1.RandomJson.generate({ nodeCount: 5 });
};
exports.any = any;
const arr = (type) => {
    let length = Math.round(Math.random() * 10);
    const schema = type.getSchema();
    const { min, max } = schema;
    if (min !== undefined && length < min)
        length = min + length;
    if (max !== undefined && length > max)
        length = max;
    const result = [];
    for (let i = 0; i < length; i++) {
        result.push(type.type.random());
    }
    return result;
};
exports.arr = arr;
const bin = (type) => {
    const octets = json_random_1.RandomJson.genString()
        .split('')
        .map((c) => c.charCodeAt(0));
    return new Uint8Array(octets);
};
exports.bin = bin;
const bool = (type) => {
    return json_random_1.RandomJson.genBoolean();
};
exports.bool = bool;
const const_ = (type) => {
    return (0, json_clone_1.cloneBinary)(type.getSchema().value);
};
exports.const_ = const_;
const fn = (type) => {
    return async () => type.res.random();
};
exports.fn = fn;
const map = (type) => {
    const length = Math.round(Math.random() * 10);
    const res = {};
    for (let i = 0; i < length; i++) {
        res[json_random_1.RandomJson.genString(length)] = type.valueType.random();
    }
    return res;
};
exports.map = map;
const num = (type) => {
    let num = Math.random();
    let min = Number.MIN_SAFE_INTEGER;
    let max = Number.MAX_SAFE_INTEGER;
    const schema = type.getSchema();
    const { lt, lte, gt, gte } = schema;
    if (gt !== undefined)
        min = gt;
    if (gte !== undefined)
        if (gte === lte)
            return gte;
        else
            min = gte + 0.000000000000001;
    if (lt !== undefined)
        max = lt;
    if (lte !== undefined)
        max = lte - 0.000000000000001;
    if (min >= max)
        return max;
    if (schema.format) {
        switch (schema.format) {
            case 'i8':
                min = Math.max(min, -0x80);
                max = Math.min(max, 0x7f);
                break;
            case 'i16':
                min = Math.max(min, -0x8000);
                max = Math.min(max, 0x7fff);
                break;
            case 'i32':
                min = Math.max(min, -0x80000000);
                max = Math.min(max, 0x7fffffff);
                break;
            case 'i64':
            case 'i':
                min = Math.max(min, -0x8000000000);
                max = Math.min(max, 0x7fffffffff);
                break;
            case 'u8':
                min = Math.max(min, 0);
                max = Math.min(max, 0xff);
                break;
            case 'u16':
                min = Math.max(min, 0);
                max = Math.min(max, 0xffff);
                break;
            case 'u32':
                min = Math.max(min, 0);
                max = Math.min(max, 0xffffffff);
                break;
            case 'u64':
            case 'u':
                min = Math.max(min, 0);
                max = Math.min(max, 0xffffffffffff);
                break;
        }
        return Math.round(num * (max - min)) + min;
    }
    num = num * (max - min) + min;
    if (Math.random() > 0.7)
        num = Math.round(num);
    if (num === 0)
        return 0;
    return num;
};
exports.num = num;
const obj = (type) => {
    const schema = type.getSchema();
    const obj = schema.unknownFields ? json_random_1.RandomJson.genObject() : {};
    // Use runtime check to avoid circular import with ObjectOptionalFieldType
    for (const field of type.fields) {
        if (field.constructor.name === 'ObjectOptionalFieldType')
            if (Math.random() > 0.5)
                continue;
        obj[field.key] = field.value.random();
    }
    return obj;
};
exports.obj = obj;
const or = (type) => {
    const types = type.types;
    const index = Math.floor(Math.random() * types.length);
    return types[index].random();
};
exports.or = or;
const ref = (type) => {
    if (!type.system)
        throw new Error('NO_SYSTEM');
    const alias = type.system.resolve(type.getSchema().ref);
    return alias.type.random();
};
exports.ref = ref;
const str = (type) => {
    let length = Math.round(Math.random() * 10);
    const schema = type.getSchema();
    const { min, max } = schema;
    if (min !== undefined && length < min)
        length = min + length;
    if (max !== undefined && length > max)
        length = max;
    return json_random_1.RandomJson.genString(length);
};
exports.str = str;
const tup = (type) => {
    return type.types.map((subType) => subType.random());
};
exports.tup = tup;