@maroonedog/luq 0.1.2-alpha → 2.1.0

package/dist/plugins/object-max-properties/object-max-properties.d.ts

@@ -0,0 +1,10 @@
+import type { Unchanged } from "../../plugin-kit/marker.types";
+export interface ObjectMaxPropertiesContext {
+    readonly max: number;
+    readonly actual: number;
+}
+export declare const objectMaxPropertiesPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"objectMaxProperties", "maxProperties", readonly ["object"], {
+    args: readonly [max: number];
+    out: Unchanged;
+    context: ObjectMaxPropertiesContext;
+}>;

package/dist/plugins/object-max-properties/object-max-properties.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectMaxPropertiesPlugin = 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.objectMaxPropertiesPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "objectMaxProperties",
+    method: "maxProperties",
+    slots: ["object"],
+    build: (ctx, max) => {
+        if (!(0, types_1.isNumber)(max) || !Number.isFinite(max) || max < 0) {
+            throw new plugin_definition_1.PluginArgumentError(ctx.pluginName, "max", max);
+        }
+        return (0, create_rule_1.check)({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value) => {
+                if (!(0, types_1.isPlainObject)(value))
+                    return types_1.PASS;
+                const count = Object.keys(value).length;
+                return count <= max ? types_1.PASS : (0, types_1.fail)({ expected: max, actual: count });
+            },
+            describe: (detail) => `Must have at most ${String(max)} properties, but has ${String(detail.actual)}`,
+            buildMessageContext: (detail) => ({
+                max,
+                actual: (0, types_1.isNumber)(detail.actual) ? detail.actual : 0,
+            }),
+        });
+    },
+});

package/dist/plugins/object-max-properties/object-max-properties.mjs

@@ -0,0 +1,29 @@
+import { PASS, fail, isNumber, isPlainObject } from "../../types/index.mjs";
+import { check } from "../../plugin-kit/create-rule.mjs";
+import { PluginArgumentError, definePlugin, } from "../../plugin-kit/plugin-definition.mjs";
+export const objectMaxPropertiesPlugin = /*#__PURE__*/ definePlugin()({
+    name: "objectMaxProperties",
+    method: "maxProperties",
+    slots: ["object"],
+    build: (ctx, max) => {
+        if (!isNumber(max) || !Number.isFinite(max) || max < 0) {
+            throw new PluginArgumentError(ctx.pluginName, "max", max);
+        }
+        return check({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value) => {
+                if (!isPlainObject(value))
+                    return PASS;
+                const count = Object.keys(value).length;
+                return count <= max ? PASS : fail({ expected: max, actual: count });
+            },
+            describe: (detail) => `Must have at most ${String(max)} properties, but has ${String(detail.actual)}`,
+            buildMessageContext: (detail) => ({
+                max,
+                actual: isNumber(detail.actual) ? detail.actual : 0,
+            }),
+        });
+    },
+});

package/dist/plugins/object-min-properties/index.d.ts

@@ -0,0 +1,2 @@
+export { objectMinPropertiesPlugin } from "./object-min-properties";
+export type { ObjectMinPropertiesContext } from "./object-min-properties";

package/dist/plugins/object-min-properties/index.js

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

package/dist/plugins/object-min-properties/index.mjs

@@ -0,0 +1 @@
+export { objectMinPropertiesPlugin } from "./object-min-properties.mjs";

package/dist/plugins/object-min-properties/object-min-properties.d.ts

@@ -0,0 +1,10 @@
+import type { Unchanged } from "../../plugin-kit/marker.types";
+export interface ObjectMinPropertiesContext {
+    readonly min: number;
+    readonly actual: number;
+}
+export declare const objectMinPropertiesPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"objectMinProperties", "minProperties", readonly ["object"], {
+    args: readonly [min: number];
+    out: Unchanged;
+    context: ObjectMinPropertiesContext;
+}>;

package/dist/plugins/object-min-properties/object-min-properties.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectMinPropertiesPlugin = 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.objectMinPropertiesPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "objectMinProperties",
+    method: "minProperties",
+    slots: ["object"],
+    build: (ctx, min) => {
+        if (!(0, types_1.isNumber)(min) || !Number.isFinite(min) || min < 0) {
+            throw new plugin_definition_1.PluginArgumentError(ctx.pluginName, "min", min);
+        }
+        return (0, create_rule_1.check)({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value) => {
+                if (!(0, types_1.isPlainObject)(value))
+                    return types_1.PASS;
+                const count = Object.keys(value).length;
+                return count >= min ? types_1.PASS : (0, types_1.fail)({ expected: min, actual: count });
+            },
+            describe: (detail) => `Must have at least ${String(min)} properties, but has ${String(detail.actual)}`,
+            buildMessageContext: (detail) => ({
+                min,
+                actual: (0, types_1.isNumber)(detail.actual) ? detail.actual : 0,
+            }),
+        });
+    },
+});

package/dist/plugins/object-min-properties/object-min-properties.mjs

@@ -0,0 +1,29 @@
+import { PASS, fail, isNumber, isPlainObject } from "../../types/index.mjs";
+import { check } from "../../plugin-kit/create-rule.mjs";
+import { PluginArgumentError, definePlugin, } from "../../plugin-kit/plugin-definition.mjs";
+export const objectMinPropertiesPlugin = /*#__PURE__*/ definePlugin()({
+    name: "objectMinProperties",
+    method: "minProperties",
+    slots: ["object"],
+    build: (ctx, min) => {
+        if (!isNumber(min) || !Number.isFinite(min) || min < 0) {
+            throw new PluginArgumentError(ctx.pluginName, "min", min);
+        }
+        return check({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value) => {
+                if (!isPlainObject(value))
+                    return PASS;
+                const count = Object.keys(value).length;
+                return count >= min ? PASS : fail({ expected: min, actual: count });
+            },
+            describe: (detail) => `Must have at least ${String(min)} properties, but has ${String(detail.actual)}`,
+            buildMessageContext: (detail) => ({
+                min,
+                actual: isNumber(detail.actual) ? detail.actual : 0,
+            }),
+        });
+    },
+});

package/dist/plugins/object-pattern-properties/index.d.ts

@@ -0,0 +1,2 @@
+export { objectPatternPropertiesPlugin } from "./object-pattern-properties";
+export type { PatternPropertiesExtra } from "./object-pattern-properties";

package/dist/plugins/object-pattern-properties/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectPatternPropertiesPlugin = void 0;
+var object_pattern_properties_1 = require("./object-pattern-properties");
+Object.defineProperty(exports, "objectPatternPropertiesPlugin", { enumerable: true, get: function () { return object_pattern_properties_1.objectPatternPropertiesPlugin; } });

package/dist/plugins/object-pattern-properties/index.mjs

@@ -0,0 +1 @@
+export { objectPatternPropertiesPlugin } from "./object-pattern-properties.mjs";

package/dist/plugins/object-pattern-properties/object-pattern-properties.d.ts

@@ -0,0 +1,16 @@
+import type { PropertyValueChain, Unchanged } from "../../plugin-kit/marker.types";
+export interface PatternPropertiesExtra {
+    readonly violatingProperties: readonly string[];
+}
+/**
+ * WHICH argument positions carry a sub-chain cannot be recovered from a
+ * plugin's type at run time — a NarrowedChain and a RootPredicate are both
+ * plain functions once erased — so src/chain/collect-branch-rules.ts reads it
+ * from this declared field. definePlugin's spec does not carry it yet (see
+ * needsFromOthers), which is why it is spread on rather than passed in.
+ */
+export declare const objectPatternPropertiesPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"objectPatternProperties", "patternProperties", readonly ["object"], {
+    args: readonly [patterns: Readonly<Record<string, PropertyValueChain>>];
+    out: Unchanged;
+    context: PatternPropertiesExtra;
+}>;

package/dist/plugins/object-pattern-properties/object-pattern-properties.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectPatternPropertiesPlugin = void 0;
+// ===========================================================================
+// L7  src/plugins/object-pattern-properties/object-pattern-properties.ts
+// A KEYED set of PROPERTY-VALUE sub-chains. Draft-07 semantics: every matching
+// pattern applies (legacy broke after the first match, which
+// plugin-catalog-structural.md lists as deliberately not carried over).
+// ===========================================================================
+const types_1 = require("../../types");
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+/**
+ * WHICH argument positions carry a sub-chain cannot be recovered from a
+ * plugin's type at run time — a NarrowedChain and a RootPredicate are both
+ * plain functions once erased — so src/chain/collect-branch-rules.ts reads it
+ * from this declared field. definePlugin's spec does not carry it yet (see
+ * needsFromOthers), which is why it is spread on rather than passed in.
+ */
+exports.objectPatternPropertiesPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "objectPatternProperties",
+    method: "patternProperties",
+    slots: ["object"],
+    build: (ctx, patterns) => {
+        const entries = Object.entries(patterns);
+        const matchers = entries.map(([pattern]) => new RegExp(pattern));
+        return (0, create_rule_1.composite)({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            branches: entries.map(([pattern, rules]) => (0, create_rule_1.branch)(pattern, rules)),
+            combine: (runners) => (value, runCtx) => {
+                if (!(0, types_1.isPlainObject)(value))
+                    return types_1.PASS;
+                const violating = [];
+                for (const key of Object.keys(value)) {
+                    for (let index = 0; index < runners.length; index += 1) {
+                        const matcher = matchers[index];
+                        const runner = runners[index];
+                        if (matcher === undefined ||
+                            runner === undefined ||
+                            !matcher.test(key))
+                            continue;
+                        if (!runner.run(value[key], runCtx).ok)
+                            violating.push(key);
+                    }
+                }
+                return violating.length === 0 ? types_1.PASS : (0, types_1.fail)({ actual: violating });
+            },
+            describe: (detail) => `Properties failing their pattern schema: ${String(detail.actual)}`,
+            buildMessageContext: (detail) => ({
+                violatingProperties: (0, types_1.isStringArray)(detail.actual) ? detail.actual : [],
+            }),
+        });
+    },
+    subChainArguments: [0],
+});

package/dist/plugins/object-pattern-properties/object-pattern-properties.mjs

@@ -0,0 +1,54 @@
+// ===========================================================================
+// L7  src/plugins/object-pattern-properties/object-pattern-properties.ts
+// A KEYED set of PROPERTY-VALUE sub-chains. Draft-07 semantics: every matching
+// pattern applies (legacy broke after the first match, which
+// plugin-catalog-structural.md lists as deliberately not carried over).
+// ===========================================================================
+import { PASS, fail, isPlainObject, isStringArray } from "../../types/index.mjs";
+import { branch, composite } from "../../plugin-kit/create-rule.mjs";
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+/**
+ * WHICH argument positions carry a sub-chain cannot be recovered from a
+ * plugin's type at run time — a NarrowedChain and a RootPredicate are both
+ * plain functions once erased — so src/chain/collect-branch-rules.ts reads it
+ * from this declared field. definePlugin's spec does not carry it yet (see
+ * needsFromOthers), which is why it is spread on rather than passed in.
+ */
+export const objectPatternPropertiesPlugin = /*#__PURE__*/ definePlugin()({
+    name: "objectPatternProperties",
+    method: "patternProperties",
+    slots: ["object"],
+    build: (ctx, patterns) => {
+        const entries = Object.entries(patterns);
+        const matchers = entries.map(([pattern]) => new RegExp(pattern));
+        return composite({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            branches: entries.map(([pattern, rules]) => branch(pattern, rules)),
+            combine: (runners) => (value, runCtx) => {
+                if (!isPlainObject(value))
+                    return PASS;
+                const violating = [];
+                for (const key of Object.keys(value)) {
+                    for (let index = 0; index < runners.length; index += 1) {
+                        const matcher = matchers[index];
+                        const runner = runners[index];
+                        if (matcher === undefined ||
+                            runner === undefined ||
+                            !matcher.test(key))
+                            continue;
+                        if (!runner.run(value[key], runCtx).ok)
+                            violating.push(key);
+                    }
+                }
+                return violating.length === 0 ? PASS : fail({ actual: violating });
+            },
+            describe: (detail) => `Properties failing their pattern schema: ${String(detail.actual)}`,
+            buildMessageContext: (detail) => ({
+                violatingProperties: isStringArray(detail.actual) ? detail.actual : [],
+            }),
+        });
+    },
+    subChainArguments: [0],
+});

package/dist/plugins/object-property-names/index.d.ts

@@ -0,0 +1,2 @@
+export { objectPropertyNamesPlugin } from "./object-property-names";
+export type { PropertyNamesExtra } from "./object-property-names";

package/dist/plugins/object-property-names/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectPropertyNamesPlugin = void 0;
+var object_property_names_1 = require("./object-property-names");
+Object.defineProperty(exports, "objectPropertyNamesPlugin", { enumerable: true, get: function () { return object_property_names_1.objectPropertyNamesPlugin; } });

package/dist/plugins/object-property-names/index.mjs

@@ -0,0 +1 @@
+export { objectPropertyNamesPlugin } from "./object-property-names.mjs";

package/dist/plugins/object-property-names/object-property-names.d.ts

@@ -0,0 +1,16 @@
+import type { PropertyKeyChain, Unchanged } from "../../plugin-kit/marker.types";
+export interface PropertyNamesExtra {
+    readonly invalidPropertyNames: readonly string[];
+}
+/**
+ * WHICH argument positions carry a sub-chain cannot be recovered from a
+ * plugin's type at run time — a NarrowedChain and a RootPredicate are both
+ * plain functions once erased — so src/chain/collect-branch-rules.ts reads it
+ * from this declared field. definePlugin's spec does not carry it yet (see
+ * needsFromOthers), which is why it is spread on rather than passed in.
+ */
+export declare const objectPropertyNamesPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"objectPropertyNames", "propertyNames", readonly ["object"], {
+    args: readonly [define: PropertyKeyChain];
+    out: Unchanged;
+    context: PropertyNamesExtra;
+}>;

package/dist/plugins/object-property-names/object-property-names.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectPropertyNamesPlugin = void 0;
+// ===========================================================================
+// L7  src/plugins/object-property-names/object-property-names.ts
+// A PROPERTY-KEY sub-chain. The subject is the key, a string. It is not
+// reachable from TValue by any route -- not through ElementOf, not through
+// Present, not through PropertyValueOf -- which is why the registry needed a
+// second new marker rather than a reuse of the first.
+// ===========================================================================
+const types_1 = require("../../types");
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+/**
+ * WHICH argument positions carry a sub-chain cannot be recovered from a
+ * plugin's type at run time — a NarrowedChain and a RootPredicate are both
+ * plain functions once erased — so src/chain/collect-branch-rules.ts reads it
+ * from this declared field. definePlugin's spec does not carry it yet (see
+ * needsFromOthers), which is why it is spread on rather than passed in.
+ */
+exports.objectPropertyNamesPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "objectPropertyNames",
+    method: "propertyNames",
+    slots: ["object"],
+    build: (ctx, define) => (0, create_rule_1.composite)({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        branches: [(0, create_rule_1.branch)("propertyName", define)],
+        combine: (runners) => {
+            const runner = runners[0];
+            if (runner === undefined)
+                return () => types_1.PASS;
+            return (value, runCtx) => {
+                if (!(0, types_1.isPlainObject)(value))
+                    return types_1.PASS;
+                const invalid = Object.keys(value).filter((key) => !runner.run(key, runCtx).ok);
+                return invalid.length === 0 ? types_1.PASS : (0, types_1.fail)({ actual: invalid });
+            };
+        },
+        describe: (detail) => `Invalid property names: ${String(detail.actual)}`,
+        buildMessageContext: (detail) => ({
+            invalidPropertyNames: (0, types_1.isStringArray)(detail.actual) ? detail.actual : [],
+        }),
+    }),
+    subChainArguments: [0],
+});

package/dist/plugins/object-property-names/object-property-names.mjs

@@ -0,0 +1,44 @@
+// ===========================================================================
+// L7  src/plugins/object-property-names/object-property-names.ts
+// A PROPERTY-KEY sub-chain. The subject is the key, a string. It is not
+// reachable from TValue by any route -- not through ElementOf, not through
+// Present, not through PropertyValueOf -- which is why the registry needed a
+// second new marker rather than a reuse of the first.
+// ===========================================================================
+import { PASS, fail, isPlainObject, isStringArray } from "../../types/index.mjs";
+import { branch, composite } from "../../plugin-kit/create-rule.mjs";
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+/**
+ * WHICH argument positions carry a sub-chain cannot be recovered from a
+ * plugin's type at run time — a NarrowedChain and a RootPredicate are both
+ * plain functions once erased — so src/chain/collect-branch-rules.ts reads it
+ * from this declared field. definePlugin's spec does not carry it yet (see
+ * needsFromOthers), which is why it is spread on rather than passed in.
+ */
+export const objectPropertyNamesPlugin = /*#__PURE__*/ definePlugin()({
+    name: "objectPropertyNames",
+    method: "propertyNames",
+    slots: ["object"],
+    build: (ctx, define) => composite({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        branches: [branch("propertyName", define)],
+        combine: (runners) => {
+            const runner = runners[0];
+            if (runner === undefined)
+                return () => PASS;
+            return (value, runCtx) => {
+                if (!isPlainObject(value))
+                    return PASS;
+                const invalid = Object.keys(value).filter((key) => !runner.run(key, runCtx).ok);
+                return invalid.length === 0 ? PASS : fail({ actual: invalid });
+            };
+        },
+        describe: (detail) => `Invalid property names: ${String(detail.actual)}`,
+        buildMessageContext: (detail) => ({
+            invalidPropertyNames: isStringArray(detail.actual) ? detail.actual : [],
+        }),
+    }),
+    subChainArguments: [0],
+});

package/dist/plugins/object-recursively/index.d.ts

@@ -0,0 +1,2 @@
+export { objectRecursivelyPlugin } from "./object-recursively";
+export type { RecursivelyOptions } from "./object-recursively";

package/dist/plugins/object-recursively/index.js

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

package/dist/plugins/object-recursively/index.mjs

@@ -0,0 +1 @@
+export { objectRecursivelyPlugin } from "./object-recursively.mjs";

package/dist/plugins/object-recursively/object-recursively.d.ts

@@ -0,0 +1,11 @@
+import type { MessageContextExtra } from "../../types";
+import type { Unchanged } from "../../plugin-kit/marker.types";
+import type { RecursionTarget } from "../../plugin-kit/compiled-rule";
+export interface RecursivelyOptions {
+    readonly maxDepth?: number;
+}
+export declare const objectRecursivelyPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"objectRecursively", "recursively", readonly ["object", "array"], {
+    args: readonly [target: RecursionTarget, options?: RecursivelyOptions];
+    out: Unchanged;
+    context: MessageContextExtra;
+}>;

package/dist/plugins/object-recursively/object-recursively.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectRecursivelyPlugin = void 0;
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const DEFAULT_MAX_DEPTH = 10;
+exports.objectRecursivelyPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "objectRecursively",
+    method: "recursively",
+    slots: ["object", "array"],
+    build: (ctx, target, options) => {
+        const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+        if (!Number.isInteger(maxDepth) || maxDepth < 1) {
+            throw new plugin_definition_1.PluginArgumentError(ctx.pluginName, "maxDepth", maxDepth);
+        }
+        return (0, create_rule_1.recursive)({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            target,
+            maxDepth,
+            describe: (detail) => `Recursive validation stopped at the maximum depth of ${String(detail.expected)}`,
+            buildMessageContext: () => ({}),
+        });
+    },
+});

package/dist/plugins/object-recursively/object-recursively.mjs

@@ -0,0 +1,23 @@
+import { recursive } from "../../plugin-kit/create-rule.mjs";
+import { PluginArgumentError, definePlugin, } from "../../plugin-kit/plugin-definition.mjs";
+const DEFAULT_MAX_DEPTH = 10;
+export const objectRecursivelyPlugin = /*#__PURE__*/ definePlugin()({
+    name: "objectRecursively",
+    method: "recursively",
+    slots: ["object", "array"],
+    build: (ctx, target, options) => {
+        const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+        if (!Number.isInteger(maxDepth) || maxDepth < 1) {
+            throw new PluginArgumentError(ctx.pluginName, "maxDepth", maxDepth);
+        }
+        return recursive({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            target,
+            maxDepth,
+            describe: (detail) => `Recursive validation stopped at the maximum depth of ${String(detail.expected)}`,
+            buildMessageContext: () => ({}),
+        });
+    },
+});

package/dist/plugins/object.d.ts

@@ -1,43 +1 @@
-import { ValidationOptions } from "../core/plugin/types";
-/**
- * @luq-plugin
- * @name object
- * @category standard
- * @description Validates that a value is a plain object (not null, array, or other types)
- * @allowedTypes ["object"]
- * @example
- * ```typescript
- * // Basic usage - validates that value is an object
- * const validator = Builder()
- *   .use(objectPlugin)
- *   .for<FormData>()
- *   .v("settings", (b) => b.object.object())
- *   .v("config", (b) => b.object.required().object())
- *   .build();
- *
- * // For nested object validation
- * builder.v("data", b => b.object.object())
- *   .v("data.name", b => b.string.required())
- *   .v("data.age", b => b.number.min(0))
- *
- * // Combined with required for mandatory objects
- * builder.v("user", b => b.object.required().object())
- * ```
- * @params
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that returns true if value is a plain object
- * @customError
- * ```typescript
- * .object({
- *   messageFactory: ({ path, value }) =>
- *     `${path} must be an object (received: ${typeof value})`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const objectPlugin: import("../index").TypedPlugin<"object", "object", (options?: ValidationOptions) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: ValidationOptions<{}>[];
-}, readonly ["object"], "validator", "standard">;
+export * from "./object/index";

package/dist/plugins/object.js

@@ -1 +1,2 @@
-"use strict";var l=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var u=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var g=(e,n)=>{for(var a in n)l(e,a,{get:n[a],enumerable:!0})},y=(e,n,a,t)=>{if(n&&typeof n=="object"||typeof n=="function")for(let r of u(n))!d.call(e,r)&&r!==a&&l(e,r,{get:()=>n[r],enumerable:!(t=p(n,r))||t.enumerable});return e};var c=e=>y(l({},"__esModule",{value:!0}),e);var C={};g(C,{objectPlugin:()=>P});module.exports=c(C);var f=(e,n,a,t)=>{let m=(o=>(...s)=>{let i=o(...s);return i&&typeof i=="object"&&"check"in i?{...i,pluginName:t}:i})(a);switch(e){case"conditional":return(o,...s)=>m(o,...s);case"fieldReference":return(o,...s)=>m(o,...s);case"multiFieldReference":return m;case"transform":return o=>m(o);case"arrayElement":return(o,...s)=>m(o,...s);case"context":return o=>m(o);default:return m}};function T(e){let{name:n,methodName:a,allowedTypes:t,category:r,impl:m}=e;return{name:n,methodName:a,allowedTypes:t,category:r,create:()=>f(r,a,m,n)}}var N="type_mismatch",x="Not an object";function h(e){return x}var I=["object"],P=T({name:"object",methodName:"object",allowedTypes:I,category:"standard",impl:e=>{let n=e?.code||N,a=e?.messageFactory||h;return{check:t=>t!==null&&typeof t=="object"&&!Array.isArray(t),code:n,getErrorMessage:(t,r)=>a({path:r,value:t,code:n}),params:e?[e]:[]}}});0&&(module.exports={objectPlugin});
+"use strict";
+module.exports = require("./object/index");

package/dist/plugins/object.mjs

@@ -1 +1 @@
-var T=(t,o,m,a)=>{let n=(e=>(...r)=>{let i=e(...r);return i&&typeof i=="object"&&"check"in i?{...i,pluginName:a}:i})(m);switch(t){case"conditional":return(e,...r)=>n(e,...r);case"fieldReference":return(e,...r)=>n(e,...r);case"multiFieldReference":return n;case"transform":return e=>n(e);case"arrayElement":return(e,...r)=>n(e,...r);case"context":return e=>n(e);default:return n}};function l(t){let{name:o,methodName:m,allowedTypes:a,category:s,impl:n}=t;return{name:o,methodName:m,allowedTypes:a,category:s,create:()=>T(s,m,n,o)}}var p="type_mismatch",u="Not an object";function d(t){return u}var g=["object"],f=l({name:"object",methodName:"object",allowedTypes:g,category:"standard",impl:t=>{let o=t?.code||p,m=t?.messageFactory||d;return{check:a=>a!==null&&typeof a=="object"&&!Array.isArray(a),code:o,getErrorMessage:(a,s)=>m({path:s,value:a,code:o}),params:t?[t]:[]}}});export{f as objectPlugin};
+export * from "./object/index.mjs";

package/dist/plugins/objectAdditionalProperties.d.ts

@@ -1,51 +1 @@
-import { ValidationOptions } from "../core/plugin/types";
-import type { JSONSchema7 } from "json-schema";
-interface AdditionalPropertiesOptions extends ValidationOptions {
-    allowedProperties?: string[];
-    additionalPropertiesSchema?: JSONSchema7;
-    strict?: boolean;
-}
-/**
- * @luq-plugin
- * @name objectAdditionalProperties
- * @category standard
- * @description Validates additional properties in objects according to JSON Schema additionalProperties rules
- * @allowedTypes ["object"]
- * @example
- * ```typescript
- * // Strict mode - no additional properties allowed
- * const validator = Builder()
- *   .use(objectAdditionalPropertiesPlugin)
- *   .for<UserData>()
- *   .v("user", (b) => b.object.additionalProperties(false, {
- *     allowedProperties: ["name", "age", "email"]
- *   }))
- *   .build();
- *
- * // With schema validation for additional properties
- * builder.v("config", b => b.object.additionalProperties({
- *   type: "string",
- *   minLength: 1
- * }))
- * ```
- * @params
- * - allowed: boolean | JSONSchema7 - Whether additional properties are allowed or schema for validation
- * - options?: AdditionalPropertiesOptions - Configuration including allowed property names
- * @returns Validation function that validates additional properties according to rules
- * @customError
- * ```typescript
- * .additionalProperties(false, {
- *   allowedProperties: ["name", "age"],
- *   messageFactory: ({ path, value }) =>
- *     `${path} has unexpected properties: ${Object.keys(value).filter(k => !allowedProps.includes(k)).join(", ")}`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const objectAdditionalPropertiesPlugin: import("../index").TypedPlugin<"objectAdditionalProperties", "additionalProperties", (allowed: boolean | JSONSchema7, options?: AdditionalPropertiesOptions) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: (boolean | JSONSchema7 | AdditionalPropertiesOptions)[];
-}, readonly ["object"], "validator", "standard">;
-export {};
+export * from "./object-additional-properties/index";

package/dist/plugins/objectAdditionalProperties.js

@@ -1 +1,2 @@
-"use strict";var c=Object.defineProperty;var g=Object.getOwnPropertyDescriptor;var f=Object.getOwnPropertyNames;var h=Object.prototype.hasOwnProperty;var x=(r,t)=>{for(var i in t)c(r,i,{get:t[i],enumerable:!0})},N=(r,t,i,m)=>{if(t&&typeof t=="object"||typeof t=="function")for(let s of f(t))!h.call(r,s)&&s!==i&&c(r,s,{get:()=>t[s],enumerable:!(m=g(t,s))||m.enumerable});return r};var P=r=>N(c({},"__esModule",{value:!0}),r);var w={};x(w,{objectAdditionalPropertiesPlugin:()=>j});module.exports=P(w);var I=(r,t,i,m)=>{let e=(a=>(...n)=>{let l=a(...n);return l&&typeof l=="object"&&"check"in l?{...l,pluginName:m}:l})(i);switch(r){case"conditional":return(a,...n)=>e(a,...n);case"fieldReference":return(a,...n)=>e(a,...n);case"multiFieldReference":return e;case"transform":return a=>e(a);case"arrayElement":return(a,...n)=>e(a,...n);case"context":return a=>e(a);default:return e}};function y(r){let{name:t,methodName:i,allowedTypes:m,category:s,impl:e}=r;return{name:t,methodName:i,allowedTypes:m,category:s,create:()=>I(s,i,e,t)}}var b="objectAdditionalProperties",C=["object"],j=y({name:"objectAdditionalProperties",methodName:"additionalProperties",allowedTypes:C,category:"standard",impl:(r,t)=>{let i=t?.code||b,m=t?.allowedProperties||[],s=r===!1||t?.strict===!0,e=typeof r=="object"?r:t?.additionalPropertiesSchema,a=t?.messageFactory||(n=>s?`Additional properties are not allowed: ${n.extraProperties.join(", ")}`:"Additional properties validation failed");return{check:n=>{if(typeof n!="object"||n===null)return!0;let T=Object.keys(n).filter(u=>!m.includes(u));if(s)return T.length===0;if(e)for(let u of T){let o=n[u];if(e.type){let p=e.type,d=typeof o;if(p==="string"&&d!=="string"||p==="number"&&d!=="number"||p==="boolean"&&d!=="boolean"||p==="object"&&(d!=="object"||o===null||Array.isArray(o))||p==="array"&&!Array.isArray(o))return!1}if(e.minLength&&typeof o=="string"&&o.length<e.minLength||e.maxLength&&typeof o=="string"&&o.length>e.maxLength||e.minimum!==void 0&&typeof o=="number"&&o<e.minimum||e.maximum!==void 0&&typeof o=="number"&&o>e.maximum)return!1}return!0},code:i,getErrorMessage:(n,l)=>{let u=(typeof n=="object"&&n!==null?Object.keys(n):[]).filter(p=>!m.includes(p));return a({path:l,value:n,code:i,extraProperties:u})},params:[r,t]}}});0&&(module.exports={objectAdditionalPropertiesPlugin});
+"use strict";
+module.exports = require("./object-additional-properties/index");