@pogodisco/val 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./rules";
+export * from "./utils";
+export * from "./types";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./rules";
+export * from "./utils";
+export * from "./types";

package/dist/rules/array.d.ts

@@ -0,0 +1,6 @@
+export declare const isOneOf: <T>(allowedValues: readonly T[], value: unknown) => value is T;
+export declare const arrayMax: (arr: any[], max: number) => boolean;
+export declare const arrayMin: (arr: any[], min: number) => boolean;
+export declare const allEqual: (values: readonly any[]) => boolean;
+export declare const isArray: (value: any) => value is any[];
+export declare const each: (values: readonly any[], predicate: (v: unknown) => boolean) => boolean;

package/dist/rules/array.js

@@ -0,0 +1,28 @@
+export const isOneOf = (allowedValues, value) => {
+    return allowedValues.includes(value);
+};
+export const arrayMax = (arr, max) => {
+    if (!Array.isArray(arr))
+        return false;
+    return arr.length <= max;
+};
+export const arrayMin = (arr, min) => {
+    if (!Array.isArray(arr))
+        return false;
+    return arr.length >= min;
+};
+export const allEqual = (values) => {
+    if (values.length === 0)
+        return true;
+    const firstType = typeof values[0];
+    const firstValue = values[0];
+    if (!values.every((v) => typeof v === firstType))
+        return false;
+    return values.every((v) => v === firstValue);
+};
+export const isArray = (value) => Array.isArray(value);
+export const each = (values, predicate) => {
+    if (!Array.isArray(values))
+        return false;
+    return values.every(predicate);
+};

package/dist/rules/boolean.d.ts

@@ -0,0 +1,2 @@
+export declare const isTrue: (v: boolean) => boolean;
+export declare const isFalse: (v: boolean) => boolean;

package/dist/rules/boolean.js

@@ -0,0 +1,10 @@
+export const isTrue = (v) => {
+    if (typeof v !== "boolean")
+        return false;
+    return v === true;
+};
+export const isFalse = (v) => {
+    if (typeof v !== "boolean")
+        return false;
+    return v === false;
+};

package/dist/rules/date.d.ts

@@ -0,0 +1,7 @@
+export declare const isDate: (value: any) => boolean;
+export declare const isBefore: (date: Date | string, value: any) => boolean;
+export declare const isAfter: (date: Date | string, value: any) => boolean;
+export declare const isBetween: (start: Date, end: Date, value: any) => boolean;
+export declare const isToday: () => (value: any) => boolean;
+export declare const isFutureDate: (value: any) => boolean;
+export declare const isPastDate: (value: any) => boolean;

package/dist/rules/date.js

@@ -0,0 +1,20 @@
+export const isDate = (value) => value instanceof Date && !isNaN(value.getTime());
+export const isBefore = (date, value) => {
+    const d = new Date(date);
+    return value instanceof Date && value < d;
+};
+export const isAfter = (date, value) => {
+    const d = new Date(date);
+    return value instanceof Date && value > d;
+};
+export const isBetween = (start, end, value) => value instanceof Date && value >= start && value <= end;
+export const isToday = () => (value) => {
+    if (!(value instanceof Date))
+        return false;
+    const today = new Date();
+    return (value.getFullYear() === today.getFullYear() &&
+        value.getMonth() === today.getMonth() &&
+        value.getDate() === today.getDate());
+};
+export const isFutureDate = (value) => value instanceof Date && value > new Date();
+export const isPastDate = (value) => value instanceof Date && value < new Date();

package/dist/rules/helpers.d.ts

@@ -0,0 +1,6 @@
+export declare const requiredUnless: (conditions: boolean[], v: any) => boolean;
+export declare const requiredIf: (conditions: boolean[], v: any) => boolean;
+export declare const requiredIfElseEmpty: (conditions: boolean[], v: any) => boolean;
+export declare function mustBeEmptyIf(conditions: boolean[], value: any): boolean;
+export declare const isOptional: (v: any) => boolean;
+export declare const isNotEmpty: (v: any) => boolean;

package/dist/rules/helpers.js

@@ -0,0 +1,26 @@
+export const requiredUnless = (conditions, v) => {
+    return conditions.every(Boolean)
+        ? true
+        : v !== undefined && v !== null && v !== "";
+};
+export const requiredIf = (conditions, v) => {
+    return conditions.every(Boolean)
+        ? v !== undefined && v !== null && v !== ""
+        : true;
+};
+export const requiredIfElseEmpty = (conditions, v) => {
+    return conditions.some(Boolean)
+        ? v !== undefined && v !== null && v !== ""
+        : v === undefined || v === null || v === "";
+};
+export function mustBeEmptyIf(conditions, value) {
+    return conditions.some(Boolean) ? value == null || value === "" : true;
+}
+export const isOptional = (v) => {
+    return v === undefined || v === null || v === "";
+};
+export const isNotEmpty = (v) => {
+    if (v === null || v === undefined || v === "")
+        return false;
+    return true;
+};

package/dist/rules/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./number";
+export * from "./array";
+export * from "./string";
+export * from "./boolean";
+export * from "./helpers";
+export * from "./date";
+export * from "./object";

package/dist/rules/index.js

@@ -0,0 +1,7 @@
+export * from "./number";
+export * from "./array";
+export * from "./string";
+export * from "./boolean";
+export * from "./helpers";
+export * from "./date";
+export * from "./object";

package/dist/rules/number.d.ts

@@ -0,0 +1,11 @@
+export declare const isInteger: (value: any) => boolean;
+export declare const isFloat: (value: any) => boolean;
+export declare const isPositive: (value: any) => boolean;
+export declare const isNegative: (value: any) => boolean;
+export declare const isEven: (value: any) => boolean;
+export declare const isOdd: (value: any) => boolean;
+export declare const isMultipleOf: (n: number, value: any) => boolean;
+export declare const numberGt: (v: number, gt: number) => boolean;
+export declare const numberLt: (v: number, lt: number) => boolean;
+export declare const numberMax: (v: number, max: number) => boolean;
+export declare const numberMin: (v: number, min: number) => boolean;

package/dist/rules/number.js

@@ -0,0 +1,27 @@
+export const isInteger = (value) => typeof value === "number" && Number.isInteger(value);
+export const isFloat = (value) => typeof value === "number" && !Number.isInteger(value);
+export const isPositive = (value) => typeof value === "number" && value > 0;
+export const isNegative = (value) => typeof value === "number" && value < 0;
+export const isEven = (value) => typeof value === "number" && value % 2 === 0;
+export const isOdd = (value) => typeof value === "number" && value % 2 !== 0;
+export const isMultipleOf = (n, value) => typeof value === "number" && value % n === 0;
+export const numberGt = (v, gt) => {
+    if (typeof v !== "number" || isNaN(v))
+        return false;
+    return v > gt;
+};
+export const numberLt = (v, lt) => {
+    if (typeof v !== "number" || isNaN(v))
+        return false;
+    return v < lt;
+};
+export const numberMax = (v, max) => {
+    if (typeof v !== "number" || isNaN(v))
+        return false;
+    return v <= max;
+};
+export const numberMin = (v, min) => {
+    if (typeof v !== "number" || isNaN(v))
+        return false;
+    return v >= min;
+};

package/dist/rules/object.d.ts

@@ -0,0 +1,4 @@
+export declare const isObject: (value: any) => boolean;
+export declare const hasKeys: (value: any, ...keys: string[]) => boolean;
+export declare const maxKeys: (n: number, value: any) => boolean;
+export declare const minKeys: (n: number, value: any) => boolean;

package/dist/rules/object.js

@@ -0,0 +1,4 @@
+export const isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+export const hasKeys = (value, ...keys) => isObject(value) && keys.every((key) => key in value);
+export const maxKeys = (n, value) => isObject(value) && Object.keys(value).length <= n;
+export const minKeys = (n, value) => isObject(value) && Object.keys(value).length >= n;

package/dist/rules/string.d.ts

@@ -0,0 +1,12 @@
+export declare const charsMin: (v: string, min: number) => boolean;
+export declare const contains: (substr: string, value: any) => boolean;
+export declare const startsWith: (substr: string, value: any) => boolean;
+export declare const endsWith: (substr: string, value: any) => boolean;
+export declare const hasLength: (value: any, min: number, max?: number) => boolean;
+export declare const isAlpha: (value: any) => boolean;
+export declare const isAlphanumeric: (value: any) => boolean;
+export declare const isEmail: (str: string) => boolean;
+export declare const isLowerCase: (value: any) => boolean;
+export declare const isUpperCase: (value: any) => boolean;
+export declare const matchesRegex: (regex: RegExp, value: any) => boolean;
+export declare const isSlug: (value: any) => boolean;

package/dist/rules/string.js

@@ -0,0 +1,21 @@
+export const charsMin = (v, min) => {
+    if (!v || typeof v !== "string" || v.length < min) {
+        return false;
+    }
+    return true;
+};
+export const contains = (substr, value) => typeof value === "string" && value.includes(substr);
+export const startsWith = (substr, value) => typeof value === "string" && value.startsWith(substr);
+export const endsWith = (substr, value) => typeof value === "string" && value.endsWith(substr);
+export const hasLength = (value, min, max) => typeof value === "string" &&
+    value.length >= min &&
+    (max === undefined || value.length <= max);
+export const isAlpha = (value) => typeof value === "string" && /^[a-z]+$/i.test(value);
+export const isAlphanumeric = (value) => typeof value === "string" && /^[a-z0-9]+$/i.test(value);
+export const isEmail = (str) => {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(str);
+};
+export const isLowerCase = (value) => typeof value === "string" && value === value.toLowerCase();
+export const isUpperCase = (value) => typeof value === "string" && value === value.toUpperCase();
+export const matchesRegex = (regex, value) => typeof value === "string" && regex.test(value);
+export const isSlug = (value) => typeof value === "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);

package/dist/types/index.d.ts

@@ -0,0 +1,16 @@
+import type { ValidationRule } from "../utils/validation-rule";
+export type ValidationResult = {
+    ok: boolean;
+    errors: Record<string, any>;
+};
+export type RuleResult = boolean | {
+    ok: boolean;
+} | Promise<boolean> | Promise<{
+    ok: boolean;
+}>;
+export type RuleBuilder = {
+    errors(errors: ValidationRule["errors"]): RuleBuilder;
+    bail(bail?: boolean): RuleBuilder;
+    runIf(fn: () => boolean | Promise<boolean>): RuleBuilder;
+    build(): ValidationRule;
+};

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/core-rules.d.ts

@@ -0,0 +1,68 @@
+import { ValidationRuleBuilder } from "./validation-rule-builder";
+interface Validator {
+    format: {
+        date: {
+            isDate: (value: any) => ValidationRuleBuilder;
+            isBefore: (date: string | Date, value: any) => ValidationRuleBuilder;
+            isAfter: (date: string | Date, value: any) => ValidationRuleBuilder;
+            isBetween: (start: Date, end: Date, value: any) => ValidationRuleBuilder;
+            isFuture: (date: string | Date, value: any) => ValidationRuleBuilder;
+            isPast: (date: string | Date, value: any) => ValidationRuleBuilder;
+        };
+        string: {
+            min: (v: string, min: number) => ValidationRuleBuilder;
+            email: (value: any) => ValidationRuleBuilder;
+            matchesRegex: (regex: RegExp, value: any) => ValidationRuleBuilder;
+            startsWith: (substr: string, value: any) => ValidationRuleBuilder;
+            endsWith: (substr: string, value: any) => ValidationRuleBuilder;
+            contains: (substr: string, value: any) => ValidationRuleBuilder;
+            isLowerCase: (value: any) => ValidationRuleBuilder;
+            isUpperCase: (value: any) => ValidationRuleBuilder;
+            hasLength: (value: any, min: number, max?: number | undefined) => ValidationRuleBuilder;
+            isAlpha: (value: any) => ValidationRuleBuilder;
+            isAlphanumeric: (value: any) => ValidationRuleBuilder;
+            isSlug: (value: any) => ValidationRuleBuilder;
+        };
+        boolean: {
+            isTrue: (value: any) => ValidationRuleBuilder;
+            isFalse: (value: any) => ValidationRuleBuilder;
+        };
+        number: {
+            min: (v: number, min: number) => ValidationRuleBuilder;
+            max: (v: number, max: number) => ValidationRuleBuilder;
+            gt: (v: number, gt: number) => ValidationRuleBuilder;
+            lt: (v: number, lt: number) => ValidationRuleBuilder;
+            isOdd: (value: any) => ValidationRuleBuilder;
+            isEven: (value: any) => ValidationRuleBuilder;
+            isFloat: (value: any) => ValidationRuleBuilder;
+            isInteger: (value: any) => ValidationRuleBuilder;
+            isPositive: (value: any) => ValidationRuleBuilder;
+            isMultipleOf: (n: number, value: any) => ValidationRuleBuilder;
+            isNegative: (value: any) => ValidationRuleBuilder;
+        };
+        array: {
+            isArray: (value: any) => ValidationRuleBuilder;
+            equal: (values: readonly any[]) => ValidationRuleBuilder;
+            min: (arr: any[], min: number) => ValidationRuleBuilder;
+            max: (arr: any[], max: number) => ValidationRuleBuilder;
+            each: (arr: any[], predicate: (v: any) => boolean) => ValidationRuleBuilder;
+        };
+        object: {
+            isObject: (value: any) => ValidationRuleBuilder;
+            hasKeys: (value: any, ...keys: string[]) => ValidationRuleBuilder;
+            maxKeys: (n: number, value: any) => ValidationRuleBuilder;
+            minKeys: (n: number, value: any) => ValidationRuleBuilder;
+        };
+    };
+    optional: (value: any) => ValidationRuleBuilder;
+    required: {
+        unless: (conditions: boolean[], v: any) => ValidationRuleBuilder;
+        _if: (conditions: boolean[], v: any) => ValidationRuleBuilder;
+        _ifElseEmpty: (conditions: boolean[], v: any) => ValidationRuleBuilder;
+        from: (allowedValues: readonly unknown[], value: unknown) => ValidationRuleBuilder;
+        emptyIf: (conditions: boolean[], v: any) => ValidationRuleBuilder;
+        strict: (value: any) => ValidationRuleBuilder;
+    };
+}
+export declare const v: Validator;
+export {};

package/dist/utils/core-rules.js

@@ -0,0 +1,67 @@
+import { allEqual, each, arrayMax, arrayMin, charsMin, isEmail, isNotEmpty, isOneOf, mustBeEmptyIf, numberMax, numberMin, requiredIfElseEmpty, requiredIf, requiredUnless, numberGt, numberLt, isOptional, isTrue, isFalse, matchesRegex, isAlphanumeric, isAlpha, isSlug, hasLength, startsWith, endsWith, contains, isLowerCase, isUpperCase, isOdd, isEven, isFloat, isInteger, isPositive, isMultipleOf, isNegative, isDate, isBefore, isAfter, isBetween, isFutureDate, isPastDate, isObject, isArray, hasKeys, maxKeys, minKeys, } from "../rules";
+import { wrapSyncRule } from "./wrap-sync-rule";
+export const v = {
+    format: {
+        date: {
+            isDate: wrapSyncRule(isDate),
+            isBefore: wrapSyncRule(isBefore),
+            isAfter: wrapSyncRule(isAfter),
+            isBetween: wrapSyncRule(isBetween),
+            isFuture: wrapSyncRule(isFutureDate),
+            isPast: wrapSyncRule(isPastDate),
+        },
+        string: {
+            min: wrapSyncRule(charsMin),
+            email: wrapSyncRule(isEmail),
+            matchesRegex: wrapSyncRule(matchesRegex),
+            startsWith: wrapSyncRule(startsWith),
+            endsWith: wrapSyncRule(endsWith),
+            contains: wrapSyncRule(contains),
+            isLowerCase: wrapSyncRule(isLowerCase),
+            isUpperCase: wrapSyncRule(isUpperCase),
+            hasLength: wrapSyncRule(hasLength),
+            isAlpha: wrapSyncRule(isAlpha),
+            isAlphanumeric: wrapSyncRule(isAlphanumeric),
+            isSlug: wrapSyncRule(isSlug),
+        },
+        boolean: {
+            isTrue: wrapSyncRule(isTrue),
+            isFalse: wrapSyncRule(isFalse),
+        },
+        number: {
+            min: wrapSyncRule(numberMin),
+            max: wrapSyncRule(numberMax),
+            gt: wrapSyncRule(numberGt),
+            lt: wrapSyncRule(numberLt),
+            isOdd: wrapSyncRule(isOdd),
+            isEven: wrapSyncRule(isEven),
+            isFloat: wrapSyncRule(isFloat),
+            isInteger: wrapSyncRule(isInteger),
+            isPositive: wrapSyncRule(isPositive),
+            isMultipleOf: wrapSyncRule(isMultipleOf),
+            isNegative: wrapSyncRule(isNegative),
+        },
+        array: {
+            isArray: wrapSyncRule(isArray),
+            equal: wrapSyncRule(allEqual),
+            min: wrapSyncRule(arrayMin),
+            max: wrapSyncRule(arrayMax),
+            each: wrapSyncRule(each),
+        },
+        object: {
+            isObject: wrapSyncRule(isObject),
+            hasKeys: wrapSyncRule(hasKeys),
+            maxKeys: wrapSyncRule(maxKeys),
+            minKeys: wrapSyncRule(minKeys),
+        },
+    },
+    optional: wrapSyncRule(isOptional),
+    required: {
+        unless: wrapSyncRule(requiredUnless),
+        _if: wrapSyncRule(requiredIf),
+        _ifElseEmpty: wrapSyncRule(requiredIfElseEmpty),
+        from: wrapSyncRule(isOneOf),
+        emptyIf: wrapSyncRule(mustBeEmptyIf),
+        strict: wrapSyncRule(isNotEmpty),
+    },
+};

package/dist/utils/flatten-rules.d.ts

@@ -0,0 +1,2 @@
+import { ValidationRuleBuilder } from "./validation-rule-builder";
+export declare function flattenRuleBuilders(obj: unknown): ValidationRuleBuilder[];

package/dist/utils/flatten-rules.js

@@ -0,0 +1,24 @@
+import { ValidationRuleBuilder } from "./validation-rule-builder";
+export function flattenRuleBuilders(obj) {
+    const result = [];
+    function walk(o) {
+        if (!o)
+            return;
+        if (Array.isArray(o)) {
+            for (const item of o)
+                walk(item);
+        }
+        else if (typeof o === "object") {
+            for (const value of Object.values(o)) {
+                if (value instanceof ValidationRuleBuilder) {
+                    result.push(value);
+                }
+                else {
+                    walk(value);
+                }
+            }
+        }
+    }
+    walk(obj);
+    return result;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./validate";
+export * from "./schema";
+export * from "./core-rules";
+export * from "./wrap-async-rule";
+export * from "./wrap-sync-rule";
+export * from "./flatten-rules";
+export * from "./validation-rule";
+export * from "./validation-rule-builder";

package/dist/utils/index.js

@@ -0,0 +1,8 @@
+export * from "./validate";
+export * from "./schema";
+export * from "./core-rules";
+export * from "./wrap-async-rule";
+export * from "./wrap-sync-rule";
+export * from "./flatten-rules";
+export * from "./validation-rule";
+export * from "./validation-rule-builder";

package/dist/utils/schema.d.ts

@@ -0,0 +1,3 @@
+import type { RuleBuilder } from "../types";
+import { ValidationRule } from "./validation-rule";
+export declare function schema<Ctx>(factory: (ctx: Ctx) => RuleBuilder[]): (ctx: Ctx) => ValidationRule[];

package/dist/utils/schema.js

@@ -0,0 +1,6 @@
+// schema.ts
+export function schema(factory) {
+    return (ctx) => {
+        return factory(ctx).map((rb) => rb.build());
+    };
+}

package/dist/utils/validate.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationRule } from "./validation-rule";
+import { type TResponse } from "@pogodisco/response";
+export declare function validate({ rules, }: {
+    rules: ValidationRule[];
+}): Promise<TResponse<null>>;

package/dist/utils/validate.js

@@ -0,0 +1,28 @@
+import { newFailureResponse, newSuccessResponse, } from "@pogodisco/response";
+export async function validate({ rules, }) {
+    const validationErrors = {};
+    for (const rule of rules) {
+        if (!(await rule.shouldRun()))
+            continue;
+        const result = await rule.rule();
+        const isAppResponse = typeof result === "object" && result !== null && "ok" in result;
+        const isValid = isAppResponse ? result?.ok : result;
+        if (!isValid) {
+            for (const [key, message] of Object.entries(rule.errors)) {
+                validationErrors[key] = [
+                    ...(validationErrors[key] || []),
+                    message || "",
+                ];
+            }
+            if (rule.bail ?? true) {
+                return newFailureResponse("Validation error", {
+                    errors: validationErrors,
+                });
+            }
+        }
+    }
+    if (Object.keys(validationErrors).length > 0) {
+        return newFailureResponse("Validation error", { errors: validationErrors });
+    }
+    return newSuccessResponse(null);
+}

package/dist/utils/validation-rule-builder.d.ts

@@ -0,0 +1,13 @@
+import type { RuleResult } from "../types";
+import { ValidationRule } from "./validation-rule";
+export declare class ValidationRuleBuilder {
+    private _rule;
+    private _bail?;
+    private _errors;
+    private _runIf?;
+    constructor(rule: () => RuleResult | Promise<RuleResult>);
+    errors(errors: Partial<Record<string, string>>): this;
+    bail(bail?: boolean): this;
+    runIf(fn: () => boolean | Promise<boolean>): this;
+    build(): ValidationRule;
+}

package/dist/utils/validation-rule-builder.js

@@ -0,0 +1,27 @@
+import { ValidationRule } from "./validation-rule";
+export class ValidationRuleBuilder {
+    constructor(rule) {
+        this._errors = {};
+        this._rule = rule;
+    }
+    errors(errors) {
+        this._errors = errors;
+        return this;
+    }
+    bail(bail = true) {
+        this._bail = bail;
+        return this;
+    }
+    runIf(fn) {
+        this._runIf = fn;
+        return this;
+    }
+    build() {
+        return new ValidationRule({
+            rule: this._rule,
+            bail: this._bail,
+            errors: this._errors,
+            runIf: this._runIf,
+        });
+    }
+}

package/dist/utils/validation-rule.d.ts

@@ -0,0 +1,14 @@
+import type { RuleResult } from "../types";
+export declare class ValidationRule {
+    rule: () => RuleResult | Promise<RuleResult>;
+    bail?: boolean;
+    errors: Partial<Record<string, string>>;
+    runIf?: () => boolean | Promise<boolean>;
+    constructor(options: {
+        rule: () => RuleResult | Promise<RuleResult>;
+        bail?: boolean;
+        errors?: Partial<Record<string, string>>;
+        runIf?: () => boolean | Promise<boolean>;
+    });
+    shouldRun(): Promise<boolean>;
+}

package/dist/utils/validation-rule.js

@@ -0,0 +1,14 @@
+export class ValidationRule {
+    constructor(options) {
+        this.rule = options.rule;
+        this.bail = options.bail;
+        this.errors = options.errors ?? {};
+        this.runIf = options.runIf;
+    }
+    async shouldRun() {
+        if (!this.runIf)
+            return true;
+        const result = this.runIf();
+        return typeof result === "boolean" ? result : await result;
+    }
+}

package/dist/utils/wrap-async-rule.d.ts

@@ -0,0 +1,4 @@
+import { ValidationRuleBuilder } from "./validation-rule-builder";
+export declare function wrapAsyncRule<T extends any[]>(fn: (...args: T) => Promise<{
+    ok: boolean;
+}>): (...args: T) => ValidationRuleBuilder;

package/dist/utils/wrap-async-rule.js

@@ -0,0 +1,30 @@
+import { ValidationRuleBuilder } from "./validation-rule-builder";
+export function wrapAsyncRule(fn) {
+    return (...args) => {
+        const ruleFn = async () => {
+            const result = await fn(...args);
+            return result.ok;
+        };
+        const builder = new ValidationRuleBuilder(ruleFn);
+        const ruleName = fn.name;
+        if (ruleName === "isOptional") {
+            builder.runIf(async () => {
+                const result = await fn(...args);
+                return result.ok;
+            });
+        }
+        if (ruleName === "isTrue" || ruleName === "isFalse") {
+            builder.runIf(async () => {
+                const result = await fn(...args);
+                return result.ok;
+            });
+        }
+        if (["requiredIf", "requiredUnless", "requiredIfElseEmpty"].includes(ruleName)) {
+            const [conditions] = args;
+            if (Array.isArray(conditions)) {
+                builder.runIf(async () => conditions.every(Boolean));
+            }
+        }
+        return builder;
+    };
+}

package/dist/utils/wrap-sync-rule.d.ts

@@ -0,0 +1,2 @@
+import { ValidationRuleBuilder } from "./validation-rule-builder";
+export declare function wrapSyncRule<T extends any[]>(fn: (...args: T) => boolean): (...args: T) => ValidationRuleBuilder;

package/dist/utils/wrap-sync-rule.js

@@ -0,0 +1,21 @@
+import { ValidationRuleBuilder } from "./validation-rule-builder";
+export function wrapSyncRule(fn) {
+    return (...args) => {
+        const ruleFn = () => fn(...args);
+        const builder = new ValidationRuleBuilder(ruleFn);
+        const ruleName = fn.name;
+        if (ruleName === "isOptional") {
+            builder.runIf(() => fn(...args));
+        }
+        if (ruleName === "isTrue" || ruleName === "isFalse") {
+            builder.runIf(() => fn(...args));
+        }
+        if (["requiredIf", "requiredUnless", "requiredIfElseEmpty"].includes(ruleName)) {
+            const [conditions] = args;
+            if (Array.isArray(conditions)) {
+                builder.runIf(() => conditions.every(Boolean));
+            }
+        }
+        return builder;
+    };
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@pogodisco/val",
+  "version": "0.0.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Jakub Bystroński",
+  "description": "client / server typescript validator",
+  "keywords": [
+    "validator",
+    "typescript"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "@pogodisco/response": "^0.0.1",
+    "typescript": "^5.0.0"
+  },
+  "devDependencies": {
+    "@pogodisco/response": "^0.0.1"
+  }
+}