@purespectrum1/purescore-client 0.7.0

package/lib/validation/builder.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationBuilder = void 0;
+const validators_1 = require("./validators");
+const composite_1 = require("./composite");
+/**
+ * Fluent assembly of the rules that apply to one field.
+ *
+ * `ValidationBuilder.of({ value, fieldName }).required().interpolated().build()`
+ * reads as the requirement itself, and keeps the field name stated once instead
+ * of repeated into every rule.
+ */
+class ValidationBuilder {
+    constructor(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    value, fieldName, validators = [], skipWhenEmpty = false) {
+        this.value = value;
+        this.fieldName = fieldName;
+        this.validators = validators;
+        this.skipWhenEmpty = skipWhenEmpty;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static of({ value, fieldName }) {
+        return new ValidationBuilder(value, fieldName);
+    }
+    /**
+     * An absent or blank value passes every rule; the rules only apply to a value
+     * that is actually there.
+     */
+    optional() {
+        this.skipWhenEmpty = true;
+        return this;
+    }
+    /** The value must be a non-empty, non-whitespace string. */
+    required() {
+        this.validators.push(new validators_1.RequiredString(this.value, this.fieldName));
+        return this;
+    }
+    /** The value must be a finite number greater than zero. */
+    positiveNumber() {
+        this.validators.push(new validators_1.PositiveNumber(this.value, this.fieldName));
+        return this;
+    }
+    /** The survey platform must have interpolated the value. */
+    interpolated() {
+        this.validators.push(new validators_1.InterpolatedTemplate(this.value, this.fieldName));
+        return this;
+    }
+    /** When present, the value must parse to a JSON object. */
+    jsonObject() {
+        this.validators.push(new validators_1.JsonObject(this.value, this.fieldName));
+        return this;
+    }
+    /** The value must be shaped like an ISO 3166-1 alpha-2 country code. */
+    countryCode() {
+        this.validators.push(new validators_1.CountryCode(this.value, this.fieldName));
+        return this;
+    }
+    /** The value must be shaped like an ISO 639-1 language code. */
+    languageCode() {
+        this.validators.push(new validators_1.LanguageCode(this.value, this.fieldName));
+        return this;
+    }
+    /** The value must name a function on `window`. */
+    globalFunction() {
+        this.validators.push(new validators_1.GlobalFunction(this.value, this.fieldName));
+        return this;
+    }
+    /** The value must be a usable schedule record. */
+    scheduleRecord() {
+        this.validators.push(new validators_1.ScheduleRecordShape(this.value, this.fieldName));
+        return this;
+    }
+    build() {
+        const isEmpty = this.value === undefined || this.value === null || String(this.value).trim() === '';
+        if (this.skipWhenEmpty && isEmpty)
+            return [];
+        return this.validators;
+    }
+    /** Assembles the rules and runs them, reporting the first failure. */
+    validate() {
+        return new composite_1.ValidationComposite(this.build()).validate();
+    }
+}
+exports.ValidationBuilder = ValidationBuilder;

package/lib/validation/composite.d.ts

@@ -0,0 +1,13 @@
+import { Validator } from './protocols';
+/**
+ * Runs a list of rules and reports the first failure.
+ *
+ * Composing rather than chaining `if` statements is what lets a caller state
+ * *what* must hold and stay out of the business of *how* each rule is checked or
+ * in what order the failures are reported.
+ */
+export declare class ValidationComposite implements Validator {
+    private readonly validators;
+    constructor(validators: Validator[]);
+    validate(): Error | undefined;
+}

package/lib/validation/composite.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationComposite = void 0;
+/**
+ * Runs a list of rules and reports the first failure.
+ *
+ * Composing rather than chaining `if` statements is what lets a caller state
+ * *what* must hold and stay out of the business of *how* each rule is checked or
+ * in what order the failures are reported.
+ */
+class ValidationComposite {
+    constructor(validators) {
+        this.validators = validators;
+    }
+    validate() {
+        for (const validator of this.validators) {
+            const error = validator.validate();
+            if (error !== undefined)
+                return error;
+        }
+    }
+}
+exports.ValidationComposite = ValidationComposite;

package/lib/validation/errors/index.d.ts

@@ -0,0 +1,2 @@
+export * from './required-field-error';
+export * from './invalid-field-error';

package/lib/validation/errors/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./required-field-error"), exports);
+__exportStar(require("./invalid-field-error"), exports);

package/lib/validation/errors/invalid-field-error.d.ts

@@ -0,0 +1,7 @@
+export declare class InvalidFieldError extends Error {
+    /**
+     * @param fieldName - the field that failed, named as the buyer wrote it so the message points at their markup.
+     * @param reason - completes the sentence "<fieldName> <reason>".
+     */
+    constructor(fieldName: string, reason: string);
+}

package/lib/validation/errors/invalid-field-error.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidFieldError = void 0;
+class InvalidFieldError extends Error {
+    /**
+     * @param fieldName - the field that failed, named as the buyer wrote it so the message points at their markup.
+     * @param reason - completes the sentence "<fieldName> <reason>".
+     */
+    constructor(fieldName, reason) {
+        super(`${fieldName} ${reason}`);
+        this.name = 'InvalidFieldError';
+    }
+}
+exports.InvalidFieldError = InvalidFieldError;

package/lib/validation/errors/required-field-error.d.ts

@@ -0,0 +1,3 @@
+export declare class RequiredFieldError extends Error {
+    constructor(fieldName: string);
+}

package/lib/validation/errors/required-field-error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredFieldError = void 0;
+class RequiredFieldError extends Error {
+    constructor(fieldName) {
+        super(`${fieldName} is required`);
+        this.name = 'RequiredFieldError';
+    }
+}
+exports.RequiredFieldError = RequiredFieldError;

package/lib/validation/index.d.ts

@@ -0,0 +1,5 @@
+export * from './protocols';
+export * from './errors';
+export * from './validators';
+export * from './composite';
+export * from './builder';

package/lib/validation/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./protocols"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./validators"), exports);
+__exportStar(require("./composite"), exports);
+__exportStar(require("./builder"), exports);

package/lib/validation/protocols/index.d.ts

@@ -0,0 +1 @@
+export * from './validator';

package/lib/validation/protocols/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./validator"), exports);

package/lib/validation/protocols/validator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A single validation rule.
+ *
+ * The value under validation is handed to the concrete validator on
+ * construction, so `validate` takes no arguments: a validator is a rule already
+ * bound to its subject. It returns the `Error` describing the failure, or
+ * `undefined` when the value is acceptable.
+ */
+export interface Validator {
+    validate: () => Error | undefined;
+}

package/lib/validation/protocols/validator.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/validation/validators/behavioural-signal.d.ts

@@ -0,0 +1,27 @@
+import { Validator } from '../protocols';
+/**
+ * A bucket of behavioural-biometrics metrics, as the trackers report it.
+ * Structural because every field is optional in practice — the point of this
+ * rule is to find out which of them the trackers actually filled in.
+ */
+export type MetricsBucket = {
+    touchBehavior?: any;
+    cursorBehavior?: any;
+    keystrokeDynamics?: any;
+};
+/**
+ * Rejects a bucket that captured no behavioural signal of any kind.
+ *
+ * A bucket is only worthless when *both* halves are empty: every aggregate count
+ * is zero AND every detailed signal is empty. Either half alone is a real
+ * observation — a respondent who scrolled without typing still produced signal —
+ * so both are required before the bucket is thrown away.
+ */
+export declare class BehaviouralSignal implements Validator {
+    private readonly bucket;
+    private readonly fieldName;
+    constructor(bucket: MetricsBucket | null | undefined, fieldName?: string);
+    validate(): Error | undefined;
+    private countsAreZero;
+    private detailsAreEmpty;
+}

package/lib/validation/validators/behavioural-signal.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BehaviouralSignal = void 0;
+const errors_1 = require("../errors");
+function isAllFalsy(obj) {
+    if (!obj)
+        return true;
+    return Object.values(obj).every(v => !v);
+}
+/**
+ * Rejects a bucket that captured no behavioural signal of any kind.
+ *
+ * A bucket is only worthless when *both* halves are empty: every aggregate count
+ * is zero AND every detailed signal is empty. Either half alone is a real
+ * observation — a respondent who scrolled without typing still produced signal —
+ * so both are required before the bucket is thrown away.
+ */
+class BehaviouralSignal {
+    constructor(bucket, fieldName = 'behavioural biometrics bucket') {
+        this.bucket = bucket;
+        this.fieldName = fieldName;
+    }
+    validate() {
+        if (!this.bucket)
+            return new errors_1.InvalidFieldError(this.fieldName, 'is missing');
+        if (this.countsAreZero() && this.detailsAreEmpty()) {
+            return new errors_1.InvalidFieldError(this.fieldName, 'captured no behavioural signal');
+        }
+    }
+    countsAreZero() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+        const cursor = (_a = this.bucket) === null || _a === void 0 ? void 0 : _a.cursorBehavior;
+        const touch = (_b = this.bucket) === null || _b === void 0 ? void 0 : _b.touchBehavior;
+        return ((_d = (_c = cursor === null || cursor === void 0 ? void 0 : cursor.accelerationMetrics) === null || _c === void 0 ? void 0 : _c.decelerationCount) !== null && _d !== void 0 ? _d : 0) === 0
+            && ((_f = (_e = cursor === null || cursor === void 0 ? void 0 : cursor.accelerationMetrics) === null || _e === void 0 ? void 0 : _e.accelerationCount) !== null && _f !== void 0 ? _f : 0) === 0
+            && ((_h = (_g = cursor === null || cursor === void 0 ? void 0 : cursor.trajectoryMetrics) === null || _g === void 0 ? void 0 : _g.angleChanges) !== null && _h !== void 0 ? _h : 0) === 0
+            && ((_k = (_j = cursor === null || cursor === void 0 ? void 0 : cursor.scrollMetrics) === null || _j === void 0 ? void 0 : _j.totalScrollDistance) !== null && _k !== void 0 ? _k : 0) === 0
+            && ((_m = (_l = cursor === null || cursor === void 0 ? void 0 : cursor.scrollMetrics) === null || _l === void 0 ? void 0 : _l.wheelScrollCount) !== null && _m !== void 0 ? _m : 0) === 0
+            && ((_p = (_o = cursor === null || cursor === void 0 ? void 0 : cursor.scrollMetrics) === null || _o === void 0 ? void 0 : _o.dragScrollCount) !== null && _p !== void 0 ? _p : 0) === 0
+            && ((_r = (_q = cursor === null || cursor === void 0 ? void 0 : cursor.sessionInfo) === null || _q === void 0 ? void 0 : _q.totalMovements) !== null && _r !== void 0 ? _r : 0) === 0
+            && ((_t = (_s = touch === null || touch === void 0 ? void 0 : touch.swipe) === null || _s === void 0 ? void 0 : _s.swipeCount) !== null && _t !== void 0 ? _t : 0) === 0;
+    }
+    detailsAreEmpty() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        const cursor = (_a = this.bucket) === null || _a === void 0 ? void 0 : _a.cursorBehavior;
+        const touch = (_b = this.bucket) === null || _b === void 0 ? void 0 : _b.touchBehavior;
+        const keyboard = (_c = this.bucket) === null || _c === void 0 ? void 0 : _c.keystrokeDynamics;
+        return isAllFalsy(cursor === null || cursor === void 0 ? void 0 : cursor.movementMetrics)
+            && ((_e = (_d = keyboard === null || keyboard === void 0 ? void 0 : keyboard.dwellTimes) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0) === 0
+            && ((_g = (_f = keyboard === null || keyboard === void 0 ? void 0 : keyboard.flightTimes) === null || _f === void 0 ? void 0 : _f.length) !== null && _g !== void 0 ? _g : 0) === 0
+            && isAllFalsy(touch === null || touch === void 0 ? void 0 : touch.pressure)
+            && isAllFalsy(touch === null || touch === void 0 ? void 0 : touch.fingerSize)
+            && ((_k = (_j = (_h = touch === null || touch === void 0 ? void 0 : touch.swipe) === null || _h === void 0 ? void 0 : _h.swipes) === null || _j === void 0 ? void 0 : _j.length) !== null && _k !== void 0 ? _k : 0) === 0;
+    }
+}
+exports.BehaviouralSignal = BehaviouralSignal;

package/lib/validation/validators/country-code.d.ts

@@ -0,0 +1,14 @@
+import { Validator } from '../protocols';
+/**
+ * Rejects anything that is not shaped like an ISO 3166-1 alpha-2 code (`US`,
+ * `GB`, `IN`).
+ *
+ * Only the shape is checked, case-insensitively: the caller normalises the case,
+ * and a full code list would cost bundle size for typos the service can report.
+ */
+export declare class CountryCode implements Validator {
+    private readonly value;
+    private readonly fieldName;
+    constructor(value: string | undefined, fieldName: string);
+    validate(): Error | undefined;
+}

package/lib/validation/validators/country-code.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CountryCode = void 0;
+const errors_1 = require("../errors");
+/**
+ * Rejects anything that is not shaped like an ISO 3166-1 alpha-2 code (`US`,
+ * `GB`, `IN`).
+ *
+ * Only the shape is checked, case-insensitively: the caller normalises the case,
+ * and a full code list would cost bundle size for typos the service can report.
+ */
+class CountryCode {
+    constructor(value, fieldName) {
+        this.value = value;
+        this.fieldName = fieldName;
+    }
+    validate() {
+        var _a, _b;
+        if (!/^[a-z]{2}$/i.test(((_a = this.value) !== null && _a !== void 0 ? _a : '').trim())) {
+            return new errors_1.InvalidFieldError(this.fieldName, `must be a 2-letter ISO 3166-1 alpha-2 country code (e.g. US, GB), got "${(_b = this.value) !== null && _b !== void 0 ? _b : ''}"`);
+        }
+    }
+}
+exports.CountryCode = CountryCode;

package/lib/validation/validators/global-function.d.ts

@@ -0,0 +1,14 @@
+import { Validator } from '../protocols';
+/**
+ * Rejects a name that does not resolve to a function on `window`.
+ *
+ * The name has to be global: a function declared inside a module, an IIFE or a
+ * `jQuery(document).ready(...)` block is not reachable this way, and this rule is
+ * what turns that into a message the buyer can act on.
+ */
+export declare class GlobalFunction implements Validator {
+    private readonly name;
+    private readonly fieldName;
+    constructor(name: string | undefined, fieldName: string);
+    validate(): Error | undefined;
+}

package/lib/validation/validators/global-function.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalFunction = void 0;
+const errors_1 = require("../errors");
+/**
+ * Rejects a name that does not resolve to a function on `window`.
+ *
+ * The name has to be global: a function declared inside a module, an IIFE or a
+ * `jQuery(document).ready(...)` block is not reachable this way, and this rule is
+ * what turns that into a message the buyer can act on.
+ */
+class GlobalFunction {
+    constructor(name, fieldName) {
+        this.name = name;
+        this.fieldName = fieldName;
+    }
+    validate() {
+        var _a;
+        if (!((_a = this.name) === null || _a === void 0 ? void 0 : _a.trim()))
+            return new errors_1.InvalidFieldError(this.fieldName, 'is required');
+        if (typeof window === 'undefined')
+            return new errors_1.InvalidFieldError(this.fieldName, 'cannot be resolved outside a browser');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (typeof window[this.name] !== 'function') {
+            return new errors_1.InvalidFieldError(this.fieldName, `"${this.name}" is not a global function`);
+        }
+    }
+}
+exports.GlobalFunction = GlobalFunction;

package/lib/validation/validators/index.d.ts

@@ -0,0 +1,9 @@
+export * from './required-string';
+export * from './positive-number';
+export * from './interpolated-template';
+export * from './json-object';
+export * from './global-function';
+export * from './schedule-record';
+export * from './behavioural-signal';
+export * from './country-code';
+export * from './language-code';

package/lib/validation/validators/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./required-string"), exports);
+__exportStar(require("./positive-number"), exports);
+__exportStar(require("./interpolated-template"), exports);
+__exportStar(require("./json-object"), exports);
+__exportStar(require("./global-function"), exports);
+__exportStar(require("./schedule-record"), exports);
+__exportStar(require("./behavioural-signal"), exports);
+__exportStar(require("./country-code"), exports);
+__exportStar(require("./language-code"), exports);

package/lib/validation/validators/interpolated-template.d.ts

@@ -0,0 +1,14 @@
+import { Validator } from '../protocols';
+/**
+ * Rejects a value the survey platform never interpolated.
+ *
+ * Worth its own rule because the failure is silent and shared: a literal
+ * `${transaction_id}` is a perfectly usable string, so it flows through as an id
+ * that every respondent on the device would then have in common.
+ */
+export declare class InterpolatedTemplate implements Validator {
+    private readonly value;
+    private readonly fieldName;
+    constructor(value: string | undefined, fieldName: string);
+    validate(): Error | undefined;
+}

package/lib/validation/validators/interpolated-template.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterpolatedTemplate = void 0;
+const errors_1 = require("../errors");
+/**
+ * Markers left behind when a survey platform fails to interpolate a placeholder.
+ */
+const TEMPLATE_MARKERS = ['${', '{{', '{%', '<%'];
+/**
+ * Rejects a value the survey platform never interpolated.
+ *
+ * Worth its own rule because the failure is silent and shared: a literal
+ * `${transaction_id}` is a perfectly usable string, so it flows through as an id
+ * that every respondent on the device would then have in common.
+ */
+class InterpolatedTemplate {
+    constructor(value, fieldName) {
+        this.value = value;
+        this.fieldName = fieldName;
+    }
+    validate() {
+        const marker = TEMPLATE_MARKERS.find(m => { var _a; return (_a = this.value) === null || _a === void 0 ? void 0 : _a.includes(m); });
+        if (marker) {
+            return new errors_1.InvalidFieldError(this.fieldName, `looks like an uninterpolated template ("${this.value}")`);
+        }
+    }
+}
+exports.InterpolatedTemplate = InterpolatedTemplate;

package/lib/validation/validators/json-object.d.ts

@@ -0,0 +1,14 @@
+import { Validator } from '../protocols';
+/**
+ * Rejects a string that does not parse to a JSON object.
+ *
+ * An absent value passes — the attributes this guards are optional; it is only a
+ * value that is *present and unusable* that is an error. Arrays are rejected
+ * because the callers want a keyed object.
+ */
+export declare class JsonObject implements Validator {
+    private readonly value;
+    private readonly fieldName;
+    constructor(value: string | undefined, fieldName: string);
+    validate(): Error | undefined;
+}

package/lib/validation/validators/json-object.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonObject = void 0;
+const errors_1 = require("../errors");
+/**
+ * Rejects a string that does not parse to a JSON object.
+ *
+ * An absent value passes — the attributes this guards are optional; it is only a
+ * value that is *present and unusable* that is an error. Arrays are rejected
+ * because the callers want a keyed object.
+ */
+class JsonObject {
+    constructor(value, fieldName) {
+        this.value = value;
+        this.fieldName = fieldName;
+    }
+    validate() {
+        var _a;
+        if (!((_a = this.value) === null || _a === void 0 ? void 0 : _a.trim()))
+            return undefined;
+        let parsed;
+        try {
+            parsed = JSON.parse(this.value);
+        }
+        catch (_b) {
+            return new errors_1.InvalidFieldError(this.fieldName, 'is not valid JSON');
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return new errors_1.InvalidFieldError(this.fieldName, 'is not a JSON object');
+        }
+    }
+}
+exports.JsonObject = JsonObject;

package/lib/validation/validators/language-code.d.ts

@@ -0,0 +1,13 @@
+import { Validator } from '../protocols';
+/**
+ * Rejects anything that is not shaped like an ISO 639-1 code (`en`, `fr`, `de`).
+ *
+ * A locale such as `en-US` is rejected on purpose: the country travels in its
+ * own field. As with `CountryCode`, only the shape is checked.
+ */
+export declare class LanguageCode implements Validator {
+    private readonly value;
+    private readonly fieldName;
+    constructor(value: string | undefined, fieldName: string);
+    validate(): Error | undefined;
+}

package/lib/validation/validators/language-code.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LanguageCode = void 0;
+const errors_1 = require("../errors");
+/**
+ * Rejects anything that is not shaped like an ISO 639-1 code (`en`, `fr`, `de`).
+ *
+ * A locale such as `en-US` is rejected on purpose: the country travels in its
+ * own field. As with `CountryCode`, only the shape is checked.
+ */
+class LanguageCode {
+    constructor(value, fieldName) {
+        this.value = value;
+        this.fieldName = fieldName;
+    }
+    validate() {
+        var _a, _b;
+        if (!/^[a-z]{2}$/i.test(((_a = this.value) !== null && _a !== void 0 ? _a : '').trim())) {
+            return new errors_1.InvalidFieldError(this.fieldName, `must be a 2-letter ISO 639-1 language code (e.g. en, fr), got "${(_b = this.value) !== null && _b !== void 0 ? _b : ''}"`);
+        }
+    }
+}
+exports.LanguageCode = LanguageCode;

package/lib/validation/validators/positive-number.d.ts

@@ -0,0 +1,13 @@
+import { Validator } from '../protocols';
+/**
+ * Rejects anything that is not a finite number greater than zero.
+ *
+ * Takes the raw string because the values it guards arrive as HTML attributes,
+ * and the original text is what belongs in the error message.
+ */
+export declare class PositiveNumber implements Validator {
+    private readonly value;
+    private readonly fieldName;
+    constructor(value: string | undefined, fieldName: string);
+    validate(): Error | undefined;
+}

package/lib/validation/validators/positive-number.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PositiveNumber = void 0;
+const errors_1 = require("../errors");
+/**
+ * Rejects anything that is not a finite number greater than zero.
+ *
+ * Takes the raw string because the values it guards arrive as HTML attributes,
+ * and the original text is what belongs in the error message.
+ */
+class PositiveNumber {
+    constructor(value, fieldName) {
+        this.value = value;
+        this.fieldName = fieldName;
+    }
+    validate() {
+        var _a, _b;
+        const parsed = Number(this.value);
+        if (!((_a = this.value) === null || _a === void 0 ? void 0 : _a.trim()) || !isFinite(parsed) || parsed <= 0) {
+            return new errors_1.InvalidFieldError(this.fieldName, `must be a positive number, got "${(_b = this.value) !== null && _b !== void 0 ? _b : ''}"`);
+        }
+    }
+}
+exports.PositiveNumber = PositiveNumber;

package/lib/validation/validators/required-string.d.ts

@@ -0,0 +1,10 @@
+import { Validator } from '../protocols';
+/**
+ * Rejects a missing, empty or whitespace-only string.
+ */
+export declare class RequiredString implements Validator {
+    private readonly value;
+    private readonly fieldName;
+    constructor(value: string | undefined, fieldName: string);
+    validate(): Error | undefined;
+}