@freeword/meta
Version:
Meta package for Freeword: exports all core types, constants, and utilities from the src/ directory.
154 lines • 7.64 kB
JavaScript
import _ /**/ from 'lodash';
import { inspectify } from "../utils/stringify.js";
import { scrubNil } from "../utils/BaseUtils.js";
export function zcheckZodTypename(checker) {
return checker?._def?.typeName;
}
export function zShapename(checker) {
if (!isChecker(checker)) {
return 'nonChecker';
}
const zodTypename = zcheckZodTypename(checker);
if (isUnwrappable(checker)) {
return zShapename(checker.unwrap());
}
if (isPipelineCk(checker)) {
return zShapename(checker._def.out);
}
// if (isBrandedCk(checker)) { return zShapename(checker.unwrap()) }
if (isArrChecker(checker)) {
const ofname = zcheckZodTypename(checker._def?.type);
if (ofname === 'ZodString') {
return 'strArr';
}
if (ofname === 'ZodNumber') {
return 'numArr';
}
return 'anyArr';
}
return ZodToCuteNameLookup[zodTypename] ?? zodTypename;
}
// const xx = Z.string().brand('xxxxx')
// const yy = xx.unwrap
export function isChecker(checker) {
return Boolean(zcheckZodTypename(checker));
}
export function isIdkChecker(check) { return check?._def?.typeName === 'ZodAny'; }
export function isBigintChecker(check) { return check?._def?.typeName === 'ZodBigInt'; }
export function isBoolChecker(check) { return check?._def?.typeName === 'ZodBoolean'; }
export function isJsdateChecker(check) { return check?._def?.typeName === 'ZodDate'; }
export function isZneverChecker(check) { return check?._def?.typeName === 'ZodNever'; }
export function isNumChecker(check) { return check?._def?.typeName === 'ZodNumber'; }
export function isBagChecker(check) { return check?._def?.typeName === 'ZodRecord'; }
export function isStrChecker(check) { return check?._def?.typeName === 'ZodString'; }
export function isTupleChecker(check) { return check?._def?.typeName === 'ZodTuple'; }
export function isOneofChecker(check) { return check?._def?.typeName === 'ZodEnum'; }
export function isStrPipelineCk(check) { return isPipelineCk(check) && isStrChecker(check._def.out); }
export function isPipelineCk(check) { return check?._def?.typeName === 'ZodPipeline'; }
export function isBrandedCk(check) { return check?._def?.typeName === 'ZodBranded'; }
export function isUnwrappable(check) { return check?.unwrap !== undefined; }
//
export function isStrArrChecker(check) { return isArrChecker(check, 'str'); }
export function isBoolArrChecker(check) { return isArrChecker(check, 'bool'); }
export function isNumArrChecker(check) { return isArrChecker(check, 'num'); }
export function isAnyArrChecker(check) { return check?._def?.typeName === 'ZodArray'; }
export function isArrChecker(check, subtype) {
const zodname = zcheckZodTypename(check);
if (zodname !== 'ZodArray') {
return false;
}
if (!subtype) {
return true;
}
const ofname = zcheckZodTypename(check._def.type);
return (ofname === CuteToZodNameLookup[subtype]);
}
export const CuteToZodNameLookup = {
idk: 'ZodAny', bigint: 'ZodBigInt', bool: 'ZodBoolean', jsdate: 'ZodDate',
oneof: 'ZodEnum', znever: 'ZodNever', num: 'ZodNumber', bag: 'ZodRecord',
str: 'ZodString', literal: 'ZodLiteral', prom: 'ZodPromise', tuple: 'ZodTuple',
arr: 'ZodArray', strArr: 'ZodArray', numArr: 'ZodArray', anyArr: 'ZodArray',
litStr: 'ZodLiteral', obj: 'ZodObject', union: 'ZodUnion',
nullable: 'ZodNullable', branded: 'ZodBranded', effects: 'ZodEffects', intersection: 'ZodIntersection',
optional: 'ZodOptional', pipeline: 'ZodPipeline', readonly: 'ZodReadonly',
};
export const ZodShortToZodnameLookup = {
any: 'ZodAny', bigInt: 'ZodBigInt', boolean: 'ZodBoolean', date: 'ZodDate',
enum: 'ZodEnum', never: 'ZodNever', number: 'ZodNumber', record: 'ZodRecord',
string: 'ZodString', literal: 'ZodLiteral', promise: 'ZodPromise', tuple: 'ZodTuple',
array: 'ZodArray', union: 'ZodUnion', object: 'ZodObject',
nullable: 'ZodNullable', branded: 'ZodBranded', effects: 'ZodEffects', intersection: 'ZodIntersection',
optional: 'ZodOptional', pipeline: 'ZodPipeline', readonly: 'ZodReadonly',
};
export const CuteToZodtstypeLookup = {
idk: 'ZodAny', bigint: 'ZodBigInt', bool: 'ZodBoolean', jsdate: 'ZodDate',
znever: 'ZodNever', num: 'ZodNumber', bag: 'ZodRecord',
str: 'ZodString', tuple: 'ZodTuple',
literal: 'ZodLiteral<any>', prom: 'ZodPromise<any>', oneof: 'ZodEnum<StrArrNZ>',
arr: 'ZodArray<ZodAny>', strArr: 'ZodArray<ZodString>', numArr: 'ZodArray<ZodNumber>',
anyArr: 'ZodArray<ZodAny>', obj: 'ZodObject<any, any, any>', union: 'ZodUnion<any[]>',
litStr: 'ZodLiteral<string>', other: 'ZodTypeAny', nonChecker: 'any',
// nullable: 'ZodNullable', branded: 'ZodBranded', effects: 'ZodEffects', intersection: 'ZodIntersection',
// optional: 'ZodOptional', pipeline: 'ZodPipeline', readonly: 'ZodReadonly',
};
export const ZodToCuteNameLookup = {
ZodAny: 'idk', ZodBigInt: 'bigint', ZodBoolean: 'bool', ZodDate: 'jsdate', ZodNever: 'znever',
ZodNumber: 'num', ZodEnum: 'oneof', ZodRecord: 'bag', ZodString: 'str', ZodTuple: 'tuple',
ZodLiteral: 'literal', ZodArray: 'anyArr', ZodObject: 'obj', ZodPromise: 'prom', ZodUnion: 'union',
ZodBranded: 'branded', ZodEffects: 'effects', ZodPipeline: 'pipeline', ZodIntersection: 'intersection',
ZodNullable: 'nullable', ZodOptional: 'optional', ZodReadonly: 'readonly',
};
export function checkernameForZodname(zodname) { return ZodToCuteNameLookup[zodname]; }
export function zodtstypeForCheckername(checkername) { return CuteToZodtstypeLookup[checkername]; }
export function zodnameForCheckername(checkername) { return CuteToZodNameLookup[checkername]; }
// interface CheckerSummaryT extends CheckerSummary { errorMap?: any }
export function summarizeCheckerDef(checker) {
if (!checker?._def) {
return { typeName: '(prim)' };
}
function brute(obj) { return inspectify(obj).slice(0, 100); }
if (checker._def?.typeName === 'ZodOptional' || checker._def?.typeName === 'ZodNullable') {
const summ = { [checker._def?.typeName]: true, ...summarizeCheckerDef(checker._def.innerType) };
return summ;
}
const raw = { ...checker._def };
const summ = { typeName: checker._def?.typeName, ..._.omit(raw, ['type', 'innerType', 'catchall', 'items', 'options', 'errorMap']) };
if (raw.type) {
summ.type = summarizeCheckerDef(raw.type);
}
if (raw.innerType) {
summ.innerType = summarizeCheckerDef(raw.innerType);
}
if (raw.catchall) {
summ.catchall = summarizeCheckerDef(raw.catchall);
}
if (raw.items) {
summ.items = _.map(raw.items, (subcheck) => summarizeCheckerDef(subcheck));
}
if (raw.options) {
summ.options = _.map(raw.options, (subcheck) => summarizeCheckerDef(subcheck));
}
if (summ.type?.shape) {
const { shape, ...rest } = summ.type;
summ.ofShape = shape;
summ.type = rest;
}
if (summ.innerType?.shape) {
const { shape, ...rest } = summ.innerType;
summ.ofShape = shape;
summ.innerType = rest;
}
if (summ.typeName === 'ZodArray') {
summ.ofType = summ.type?.typeName ?? summ.innerType?.typeName ?? '??';
}
if (raw.shape) {
if (!_.isFunction(raw.shape)) {
summ.shape = { like: brute(summ.shape) };
return summ;
}
summ.shape = _.mapValues(raw.shape(), (subcheck) => summarizeCheckerDef(subcheck));
}
const { typeName, ofType, ...rest } = summ;
return scrubNil({ typeName, ofType, ...rest });
}
//# sourceMappingURL=ZodTypeguards.js.map