@maroonedog/luq 0.1.2-alpha → 2.1.0

package/dist/plugins/number-integer/number-integer.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberIntegerPlugin = void 0;
+const types_1 = require("../../types");
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+exports.numberIntegerPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "numberInteger",
+    method: "integer",
+    slots: ["number"],
+    build: (ctx) => (0, create_rule_1.check)({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        run: (value) => !(0, types_1.isNumber)(value) || Number.isInteger(value)
+            ? types_1.PASS
+            : (0, types_1.fail)({ expected: "an integer", actual: value }),
+        describe: () => "Value must be an integer",
+        buildMessageContext: () => ({}),
+    }),
+});

package/dist/plugins/number-integer/number-integer.mjs

@@ -0,0 +1,18 @@
+import { PASS, fail, isNumber } from "../../types/index.mjs";
+import { check } from "../../plugin-kit/create-rule.mjs";
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+export const numberIntegerPlugin = /*#__PURE__*/ definePlugin()({
+    name: "numberInteger",
+    method: "integer",
+    slots: ["number"],
+    build: (ctx) => check({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        run: (value) => !isNumber(value) || Number.isInteger(value)
+            ? PASS
+            : fail({ expected: "an integer", actual: value }),
+        describe: () => "Value must be an integer",
+        buildMessageContext: () => ({}),
+    }),
+});

package/dist/plugins/number-max/index.d.ts

@@ -0,0 +1,2 @@
+export { numberMaxPlugin } from "./number-max";
+export type { NumberMaxContext } from "./number-max";

package/dist/plugins/number-max/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberMaxPlugin = void 0;
+var number_max_1 = require("./number-max");
+Object.defineProperty(exports, "numberMaxPlugin", { enumerable: true, get: function () { return number_max_1.numberMaxPlugin; } });

package/dist/plugins/number-max/index.mjs

@@ -0,0 +1 @@
+export { numberMaxPlugin } from "./number-max.mjs";

package/dist/plugins/number-max/number-max.d.ts

@@ -0,0 +1,11 @@
+import type { Unchanged } from "../../plugin-kit/marker.types";
+export interface NumberMaxContext {
+    readonly max: number;
+    readonly actual: number;
+    readonly exclusive: boolean;
+}
+export declare const numberMaxPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"numberMax", "max", readonly ["number"], {
+    args: readonly [max: number, exclusive?: boolean];
+    out: Unchanged;
+    context: NumberMaxContext;
+}>;

package/dist/plugins/number-max/number-max.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberMaxPlugin = void 0;
+const types_1 = require("../../types");
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+exports.numberMaxPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "numberMax",
+    method: "max",
+    slots: ["number"],
+    build: (ctx, max, exclusive) => {
+        if (!(0, types_1.isNumber)(max) || Number.isNaN(max)) {
+            throw new plugin_definition_1.PluginArgumentError(ctx.pluginName, "max", max);
+        }
+        const isExclusive = exclusive === true;
+        return (0, create_rule_1.check)({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value) => {
+                if (!(0, types_1.isNumber)(value))
+                    return types_1.PASS;
+                const satisfied = isExclusive ? value < max : value <= max;
+                return satisfied ? types_1.PASS : (0, types_1.fail)({ expected: max, actual: value });
+            },
+            describe: (detail) => isExclusive
+                ? `Value must be less than ${String(max)}, but got ${String(detail.actual)}`
+                : `Value must be at most ${String(max)}, but got ${String(detail.actual)}`,
+            buildMessageContext: (detail) => ({
+                max,
+                actual: (0, types_1.isNumber)(detail.actual) ? detail.actual : Number.NaN,
+                exclusive: isExclusive,
+            }),
+        });
+    },
+});

package/dist/plugins/number-max/number-max.mjs

@@ -0,0 +1,33 @@
+import { PASS, fail, isNumber } from "../../types/index.mjs";
+import { check } from "../../plugin-kit/create-rule.mjs";
+import { PluginArgumentError, definePlugin, } from "../../plugin-kit/plugin-definition.mjs";
+export const numberMaxPlugin = /*#__PURE__*/ definePlugin()({
+    name: "numberMax",
+    method: "max",
+    slots: ["number"],
+    build: (ctx, max, exclusive) => {
+        if (!isNumber(max) || Number.isNaN(max)) {
+            throw new PluginArgumentError(ctx.pluginName, "max", max);
+        }
+        const isExclusive = exclusive === true;
+        return check({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value) => {
+                if (!isNumber(value))
+                    return PASS;
+                const satisfied = isExclusive ? value < max : value <= max;
+                return satisfied ? PASS : fail({ expected: max, actual: value });
+            },
+            describe: (detail) => isExclusive
+                ? `Value must be less than ${String(max)}, but got ${String(detail.actual)}`
+                : `Value must be at most ${String(max)}, but got ${String(detail.actual)}`,
+            buildMessageContext: (detail) => ({
+                max,
+                actual: isNumber(detail.actual) ? detail.actual : Number.NaN,
+                exclusive: isExclusive,
+            }),
+        });
+    },
+});

package/dist/plugins/number-min/index.d.ts

@@ -0,0 +1,2 @@
+export { numberMinPlugin } from "./number-min";
+export type { NumberMinContext } from "./number-min";

package/dist/plugins/number-min/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberMinPlugin = void 0;
+var number_min_1 = require("./number-min");
+Object.defineProperty(exports, "numberMinPlugin", { enumerable: true, get: function () { return number_min_1.numberMinPlugin; } });

package/dist/plugins/number-min/index.mjs

@@ -0,0 +1 @@
+export { numberMinPlugin } from "./number-min.mjs";

package/dist/plugins/number-min/number-min.d.ts

@@ -0,0 +1,11 @@
+import type { Unchanged } from "../../plugin-kit/marker.types";
+export interface NumberMinContext {
+    readonly min: number;
+    readonly actual: number;
+    readonly exclusive: boolean;
+}
+export declare const numberMinPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"numberMin", "min", readonly ["number"], {
+    args: readonly [min: number, exclusive?: boolean];
+    out: Unchanged;
+    context: NumberMinContext;
+}>;

package/dist/plugins/number-min/number-min.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberMinPlugin = void 0;
+const types_1 = require("../../types");
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+exports.numberMinPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "numberMin",
+    method: "min",
+    slots: ["number"],
+    build: (ctx, min, exclusive) => {
+        if (!(0, types_1.isNumber)(min) || Number.isNaN(min)) {
+            throw new plugin_definition_1.PluginArgumentError(ctx.pluginName, "min", min);
+        }
+        const isExclusive = exclusive === true;
+        return (0, create_rule_1.check)({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value) => {
+                if (!(0, types_1.isNumber)(value))
+                    return types_1.PASS;
+                const satisfied = isExclusive ? value > min : value >= min;
+                return satisfied ? types_1.PASS : (0, types_1.fail)({ expected: min, actual: value });
+            },
+            describe: (detail) => isExclusive
+                ? `Value must be greater than ${String(min)}, but got ${String(detail.actual)}`
+                : `Value must be at least ${String(min)}, but got ${String(detail.actual)}`,
+            // describe/buildMessageContext run only after `run` failed, and `run`
+            // only fails for a number, so the guard below is never the taken branch.
+            buildMessageContext: (detail) => ({
+                min,
+                actual: (0, types_1.isNumber)(detail.actual) ? detail.actual : Number.NaN,
+                exclusive: isExclusive,
+            }),
+        });
+    },
+});

package/dist/plugins/number-min/number-min.mjs

@@ -0,0 +1,35 @@
+import { PASS, fail, isNumber } from "../../types/index.mjs";
+import { check } from "../../plugin-kit/create-rule.mjs";
+import { PluginArgumentError, definePlugin, } from "../../plugin-kit/plugin-definition.mjs";
+export const numberMinPlugin = /*#__PURE__*/ definePlugin()({
+    name: "numberMin",
+    method: "min",
+    slots: ["number"],
+    build: (ctx, min, exclusive) => {
+        if (!isNumber(min) || Number.isNaN(min)) {
+            throw new PluginArgumentError(ctx.pluginName, "min", min);
+        }
+        const isExclusive = exclusive === true;
+        return check({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value) => {
+                if (!isNumber(value))
+                    return PASS;
+                const satisfied = isExclusive ? value > min : value >= min;
+                return satisfied ? PASS : fail({ expected: min, actual: value });
+            },
+            describe: (detail) => isExclusive
+                ? `Value must be greater than ${String(min)}, but got ${String(detail.actual)}`
+                : `Value must be at least ${String(min)}, but got ${String(detail.actual)}`,
+            // describe/buildMessageContext run only after `run` failed, and `run`
+            // only fails for a number, so the guard below is never the taken branch.
+            buildMessageContext: (detail) => ({
+                min,
+                actual: isNumber(detail.actual) ? detail.actual : Number.NaN,
+                exclusive: isExclusive,
+            }),
+        });
+    },
+});

package/dist/plugins/number-multiple-of/index.d.ts

@@ -0,0 +1,2 @@
+export { numberMultipleOfPlugin } from "./number-multiple-of";
+export type { NumberMultipleOfContext } from "./number-multiple-of";

package/dist/plugins/number-multiple-of/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberMultipleOfPlugin = void 0;
+var number_multiple_of_1 = require("./number-multiple-of");
+Object.defineProperty(exports, "numberMultipleOfPlugin", { enumerable: true, get: function () { return number_multiple_of_1.numberMultipleOfPlugin; } });

package/dist/plugins/number-multiple-of/index.mjs

@@ -0,0 +1 @@
+export { numberMultipleOfPlugin } from "./number-multiple-of.mjs";

package/dist/plugins/number-multiple-of/is-multiple-of.d.ts

@@ -0,0 +1,7 @@
+/** Decimal places in the SHORTEST round-tripping spelling of `value`. */
+export declare function countDecimalPlaces(value: number): number;
+/**
+ * `divisor` must already be finite and non-zero; number-multiple-of.ts rejects
+ * anything else at build time so this stays a pure numeric predicate.
+ */
+export declare function isMultipleOf(value: number, divisor: number): boolean;

package/dist/plugins/number-multiple-of/is-multiple-of.js

@@ -0,0 +1,61 @@
+"use strict";
+// ===========================================================================
+// L7  src/plugins/number-multiple-of/is-multiple-of.ts
+//
+// THE LEGACY BUG THIS FILE EXISTS TO KILL: 1.x wrote `value % divisor === 0`.
+// In binary floating point 0.3 % 0.1 is 0.09999999999999998, so
+// .multipleOf(0.1) REJECTED 0.3 — a value JSON Schema says is valid.
+//
+// The fix is scaled-integer comparison: shift BOTH operands by the larger of
+// their decimal-place counts, round to integers, and take the integer modulo.
+// The shift must use the MAXIMUM of the two counts, never the divisor's alone —
+// scaling 0.35 by 10 rounds it to 4 and would wrongly accept it as a multiple
+// of 0.1. Beyond the safe-integer range the scaling itself would lie, so the
+// quotient fallback takes over there.
+// ===========================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countDecimalPlaces = countDecimalPlaces;
+exports.isMultipleOf = isMultipleOf;
+/** Past this many decimal places 10**exponent stops being exact. */
+const MAX_EXACT_SCALE_EXPONENT = 15;
+/** How far the quotient may sit from a whole number in the fallback path. */
+const QUOTIENT_TOLERANCE = 1e-9;
+function countFractionDigits(text) {
+    const pointIndex = text.indexOf(".");
+    return pointIndex < 0 ? 0 : text.length - pointIndex - 1;
+}
+/** Decimal places in the SHORTEST round-tripping spelling of `value`. */
+function countDecimalPlaces(value) {
+    const text = String(value);
+    const exponentIndex = text.indexOf("e");
+    if (exponentIndex < 0)
+        return countFractionDigits(text);
+    const exponent = Number(text.slice(exponentIndex + 1));
+    const mantissaDigits = countFractionDigits(text.slice(0, exponentIndex));
+    return Math.max(mantissaDigits - exponent, 0);
+}
+function isNearWholeQuotient(value, divisor) {
+    const quotient = value / divisor;
+    return Math.abs(quotient - Math.round(quotient)) < QUOTIENT_TOLERANCE;
+}
+/**
+ * `divisor` must already be finite and non-zero; number-multiple-of.ts rejects
+ * anything else at build time so this stays a pure numeric predicate.
+ */
+function isMultipleOf(value, divisor) {
+    if (!Number.isFinite(value))
+        return false;
+    const exponent = Math.max(countDecimalPlaces(value), countDecimalPlaces(divisor));
+    if (exponent > MAX_EXACT_SCALE_EXPONENT) {
+        return isNearWholeQuotient(value, divisor);
+    }
+    const scale = 10 ** exponent;
+    const scaledValue = Math.round(value * scale);
+    const scaledDivisor = Math.round(divisor * scale);
+    if (scaledDivisor === 0)
+        return isNearWholeQuotient(value, divisor);
+    if (!Number.isSafeInteger(scaledValue)) {
+        return isNearWholeQuotient(value, divisor);
+    }
+    return scaledValue % scaledDivisor === 0;
+}

package/dist/plugins/number-multiple-of/is-multiple-of.mjs

@@ -0,0 +1,57 @@
+// ===========================================================================
+// L7  src/plugins/number-multiple-of/is-multiple-of.ts
+//
+// THE LEGACY BUG THIS FILE EXISTS TO KILL: 1.x wrote `value % divisor === 0`.
+// In binary floating point 0.3 % 0.1 is 0.09999999999999998, so
+// .multipleOf(0.1) REJECTED 0.3 — a value JSON Schema says is valid.
+//
+// The fix is scaled-integer comparison: shift BOTH operands by the larger of
+// their decimal-place counts, round to integers, and take the integer modulo.
+// The shift must use the MAXIMUM of the two counts, never the divisor's alone —
+// scaling 0.35 by 10 rounds it to 4 and would wrongly accept it as a multiple
+// of 0.1. Beyond the safe-integer range the scaling itself would lie, so the
+// quotient fallback takes over there.
+// ===========================================================================
+/** Past this many decimal places 10**exponent stops being exact. */
+const MAX_EXACT_SCALE_EXPONENT = 15;
+/** How far the quotient may sit from a whole number in the fallback path. */
+const QUOTIENT_TOLERANCE = 1e-9;
+function countFractionDigits(text) {
+    const pointIndex = text.indexOf(".");
+    return pointIndex < 0 ? 0 : text.length - pointIndex - 1;
+}
+/** Decimal places in the SHORTEST round-tripping spelling of `value`. */
+export function countDecimalPlaces(value) {
+    const text = String(value);
+    const exponentIndex = text.indexOf("e");
+    if (exponentIndex < 0)
+        return countFractionDigits(text);
+    const exponent = Number(text.slice(exponentIndex + 1));
+    const mantissaDigits = countFractionDigits(text.slice(0, exponentIndex));
+    return Math.max(mantissaDigits - exponent, 0);
+}
+function isNearWholeQuotient(value, divisor) {
+    const quotient = value / divisor;
+    return Math.abs(quotient - Math.round(quotient)) < QUOTIENT_TOLERANCE;
+}
+/**
+ * `divisor` must already be finite and non-zero; number-multiple-of.ts rejects
+ * anything else at build time so this stays a pure numeric predicate.
+ */
+export function isMultipleOf(value, divisor) {
+    if (!Number.isFinite(value))
+        return false;
+    const exponent = Math.max(countDecimalPlaces(value), countDecimalPlaces(divisor));
+    if (exponent > MAX_EXACT_SCALE_EXPONENT) {
+        return isNearWholeQuotient(value, divisor);
+    }
+    const scale = 10 ** exponent;
+    const scaledValue = Math.round(value * scale);
+    const scaledDivisor = Math.round(divisor * scale);
+    if (scaledDivisor === 0)
+        return isNearWholeQuotient(value, divisor);
+    if (!Number.isSafeInteger(scaledValue)) {
+        return isNearWholeQuotient(value, divisor);
+    }
+    return scaledValue % scaledDivisor === 0;
+}

package/dist/plugins/number-multiple-of/number-multiple-of.d.ts

@@ -0,0 +1,9 @@
+import type { Unchanged } from "../../plugin-kit/marker.types";
+export interface NumberMultipleOfContext {
+    readonly divisor: number;
+}
+export declare const numberMultipleOfPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"numberMultipleOf", "multipleOf", readonly ["number"], {
+    args: readonly [divisor: number];
+    out: Unchanged;
+    context: NumberMultipleOfContext;
+}>;

package/dist/plugins/number-multiple-of/number-multiple-of.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberMultipleOfPlugin = void 0;
+const types_1 = require("../../types");
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const is_multiple_of_1 = require("./is-multiple-of");
+exports.numberMultipleOfPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "numberMultipleOf",
+    method: "multipleOf",
+    slots: ["number"],
+    build: (ctx, divisor) => {
+        if (!(0, types_1.isNumber)(divisor) || !Number.isFinite(divisor) || divisor === 0) {
+            throw new plugin_definition_1.PluginArgumentError(ctx.pluginName, "divisor", divisor);
+        }
+        return (0, create_rule_1.check)({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value) => !(0, types_1.isNumber)(value) || (0, is_multiple_of_1.isMultipleOf)(value, divisor)
+                ? types_1.PASS
+                : (0, types_1.fail)({ expected: divisor, actual: value }),
+            describe: () => `Value must be a multiple of ${String(divisor)}`,
+            buildMessageContext: () => ({ divisor }),
+        });
+    },
+});

package/dist/plugins/number-multiple-of/number-multiple-of.mjs

@@ -0,0 +1,24 @@
+import { PASS, fail, isNumber } from "../../types/index.mjs";
+import { check } from "../../plugin-kit/create-rule.mjs";
+import { PluginArgumentError, definePlugin, } from "../../plugin-kit/plugin-definition.mjs";
+import { isMultipleOf } from "./is-multiple-of.mjs";
+export const numberMultipleOfPlugin = /*#__PURE__*/ definePlugin()({
+    name: "numberMultipleOf",
+    method: "multipleOf",
+    slots: ["number"],
+    build: (ctx, divisor) => {
+        if (!isNumber(divisor) || !Number.isFinite(divisor) || divisor === 0) {
+            throw new PluginArgumentError(ctx.pluginName, "divisor", divisor);
+        }
+        return check({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value) => !isNumber(value) || isMultipleOf(value, divisor)
+                ? PASS
+                : fail({ expected: divisor, actual: value }),
+            describe: () => `Value must be a multiple of ${String(divisor)}`,
+            buildMessageContext: () => ({ divisor }),
+        });
+    },
+});

package/dist/plugins/number-negative/index.d.ts

@@ -0,0 +1 @@
+export { numberNegativePlugin } from "./number-negative";

package/dist/plugins/number-negative/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberNegativePlugin = void 0;
+var number_negative_1 = require("./number-negative");
+Object.defineProperty(exports, "numberNegativePlugin", { enumerable: true, get: function () { return number_negative_1.numberNegativePlugin; } });

package/dist/plugins/number-negative/index.mjs

@@ -0,0 +1 @@
+export { numberNegativePlugin } from "./number-negative.mjs";

package/dist/plugins/number-negative/number-negative.d.ts

@@ -0,0 +1,7 @@
+import type { Unchanged } from "../../plugin-kit/marker.types";
+import type { MessageContextExtra } from "../../types";
+export declare const numberNegativePlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"numberNegative", "negative", readonly ["number"], {
+    args: readonly [];
+    out: Unchanged;
+    context: MessageContextExtra;
+}>;

package/dist/plugins/number-negative/number-negative.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberNegativePlugin = void 0;
+const types_1 = require("../../types");
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+exports.numberNegativePlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "numberNegative",
+    method: "negative",
+    slots: ["number"],
+    build: (ctx) => (0, create_rule_1.check)({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        run: (value) => !(0, types_1.isNumber)(value) || value < 0
+            ? types_1.PASS
+            : (0, types_1.fail)({ expected: "a negative number", actual: value }),
+        describe: () => "Value must be negative",
+        buildMessageContext: () => ({}),
+    }),
+});

package/dist/plugins/number-negative/number-negative.mjs

@@ -0,0 +1,18 @@
+import { PASS, fail, isNumber } from "../../types/index.mjs";
+import { check } from "../../plugin-kit/create-rule.mjs";
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+export const numberNegativePlugin = /*#__PURE__*/ definePlugin()({
+    name: "numberNegative",
+    method: "negative",
+    slots: ["number"],
+    build: (ctx) => check({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        run: (value) => !isNumber(value) || value < 0
+            ? PASS
+            : fail({ expected: "a negative number", actual: value }),
+        describe: () => "Value must be negative",
+        buildMessageContext: () => ({}),
+    }),
+});

package/dist/plugins/number-positive/index.d.ts

@@ -0,0 +1 @@
+export { numberPositivePlugin } from "./number-positive";

package/dist/plugins/number-positive/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberPositivePlugin = void 0;
+var number_positive_1 = require("./number-positive");
+Object.defineProperty(exports, "numberPositivePlugin", { enumerable: true, get: function () { return number_positive_1.numberPositivePlugin; } });

package/dist/plugins/number-positive/index.mjs

@@ -0,0 +1 @@
+export { numberPositivePlugin } from "./number-positive.mjs";

package/dist/plugins/number-positive/number-positive.d.ts

@@ -0,0 +1,7 @@
+import type { Unchanged } from "../../plugin-kit/marker.types";
+import type { MessageContextExtra } from "../../types";
+export declare const numberPositivePlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"numberPositive", "positive", readonly ["number"], {
+    args: readonly [];
+    out: Unchanged;
+    context: MessageContextExtra;
+}>;

package/dist/plugins/number-positive/number-positive.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberPositivePlugin = void 0;
+const types_1 = require("../../types");
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+exports.numberPositivePlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "numberPositive",
+    method: "positive",
+    slots: ["number"],
+    build: (ctx) => (0, create_rule_1.check)({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        run: (value) => !(0, types_1.isNumber)(value) || value > 0
+            ? types_1.PASS
+            : (0, types_1.fail)({ expected: "a positive number", actual: value }),
+        describe: () => "Value must be positive",
+        buildMessageContext: () => ({}),
+    }),
+});

package/dist/plugins/number-positive/number-positive.mjs

@@ -0,0 +1,18 @@
+import { PASS, fail, isNumber } from "../../types/index.mjs";
+import { check } from "../../plugin-kit/create-rule.mjs";
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+export const numberPositivePlugin = /*#__PURE__*/ definePlugin()({
+    name: "numberPositive",
+    method: "positive",
+    slots: ["number"],
+    build: (ctx) => check({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        run: (value) => !isNumber(value) || value > 0
+            ? PASS
+            : fail({ expected: "a positive number", actual: value }),
+        describe: () => "Value must be positive",
+        buildMessageContext: () => ({}),
+    }),
+});

package/dist/plugins/number-range/index.d.ts

@@ -0,0 +1,2 @@
+export { numberRangePlugin } from "./number-range";
+export type { NumberRangeContext } from "./number-range";

package/dist/plugins/number-range/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberRangePlugin = void 0;
+var number_range_1 = require("./number-range");
+Object.defineProperty(exports, "numberRangePlugin", { enumerable: true, get: function () { return number_range_1.numberRangePlugin; } });

package/dist/plugins/number-range/index.mjs

@@ -0,0 +1 @@
+export { numberRangePlugin } from "./number-range.mjs";

package/dist/plugins/number-range/number-range.d.ts

@@ -0,0 +1,11 @@
+import type { Unchanged } from "../../plugin-kit/marker.types";
+export interface NumberRangeContext {
+    readonly min: number;
+    readonly max: number;
+    readonly actual: number;
+}
+export declare const numberRangePlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"numberRange", "range", readonly ["number"], {
+    args: readonly [min: number, max: number];
+    out: Unchanged;
+    context: NumberRangeContext;
+}>;