zod-search-params/lib/v4/index.js

Zod utility for parsing search params

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseSearchParams = void 0;
var schemaChanges = [];
var modifySchema = function (zodType, key, object) {
    if (zodType._zod.def.type === 'boolean') {
        if (!object || object[key] === undefined) {
            return;
        }
        var value_1 = object[key];
        object[key] = Array.isArray(value_1)
            ? value_1.map(function (v) { return (safeJsonParse(v) ? 'true' : undefined); })
            : safeJsonParse(object[key])
                ? 'true'
                : undefined;
        // @ts-expect-error coerce
        zodType.def.coerce = true;
        schemaChanges.push(zodType._zod.def);
        return;
    }
    if (zodType._zod.def.type === 'array') {
        // @ts-expect-error element exists in array
        return modifySchema(zodType.def.element, key, object);
    }
    if (zodType._zod.def.type === 'pipe') {
        // @ts-expect-error in exists in pipe
        return modifySchema(zodType.def.in, key, object);
    }
    if ('innerType' in zodType._zod.def) {
        // @ts-expect-error innerType exists
        return modifySchema(zodType.def.innerType, key, object);
    }
    if (!object || object[key] === undefined) {
        return;
    }
    var value = object[key];
    if (value !== undefined) {
        // @ts-expect-error coerce
        zodType.def.coerce = true;
        schemaChanges.push(zodType._zod.def);
    }
    return;
};
var revertSchema = function () {
    schemaChanges.forEach(function (type) {
        if ('coerce' in type) {
            type.coerce = false;
        }
    });
    schemaChanges = [];
};
var expectsArray = function (zodType) {
    if (!(zodType === null || zodType === void 0 ? void 0 : zodType._zod.def))
        return false;
    if (zodType._zod.def.type === 'array')
        return true;
    if (zodType._zod.def.type === 'lazy') {
        // @ts-expect-error getter exists in lazy
        return expectsArray(zodType.def.getter());
    }
    if (zodType._zod.def.type === 'pipe') {
        // @ts-expect-error in exists
        return expectsArray(zodType.def.in);
    }
    if ('options' in zodType._zod.def) {
        // @ts-expect-error options exists
        return zodType._zod.def.options.some(expectsArray);
    }
    if ('innerType' in zodType._zod.def) {
        // @ts-expect-error inner type
        return expectsArray(zodType.def.innerType);
    }
    return false;
};
var isSearchParams = function (maybeSearchParams) {
    return !!(maybeSearchParams &&
        typeof maybeSearchParams === 'object' &&
        'keys' in maybeSearchParams &&
        'getAll' in maybeSearchParams &&
        maybeSearchParams.keys &&
        maybeSearchParams.getAll &&
        typeof maybeSearchParams.keys === 'function' &&
        typeof maybeSearchParams.getAll === 'function');
};
var safeJsonParse = function (string) {
    try {
        return JSON.parse(string);
    }
    catch (_a) {
        return string;
    }
};
var urlSearchParamsToObject = function (searchParams) {
    return Array.from(searchParams.keys()).reduce(function (acc, item) {
        var value = searchParams.getAll(item);
        acc[item] = value.length === 1 ? value[0] : value;
        return acc;
    }, {});
};
var parseSearchParams = function (schema, searchParams) {
    var _a;
    var object = structuredClone(__assign({}, ((_a = (isSearchParams(searchParams) ? urlSearchParamsToObject(searchParams) : searchParams)) !== null && _a !== void 0 ? _a : {})));
    var shape = schema.def.shape;
    var allTypes = Object.entries(shape);
    allTypes.forEach(function (_a) {
        var key = _a[0], type = _a[1];
        return modifySchema(type, key, object);
    });
    var keys = Object.keys(object);
    var processedObject = keys.reduce(function (acc, item) {
        if (shape[item]) {
            acc[item] = expectsArray(shape[item])
                ? Array.isArray(object[item])
                    ? object[item]
                    : [object[item]]
                : object[item];
        }
        return acc;
    }, {});
    try {
        var parsedQuery = schema.parse(processedObject);
        revertSchema();
        return parsedQuery;
    }
    catch (_b) {
        revertSchema();
        // @ts-expect-error Undefined is return only in specific case, not sure how to fix this on the types level
        return undefined;
    }
};
exports.parseSearchParams = parseSearchParams;