@platecms/delta-validation 0.1.0

package/src/lib/types/existing-content-validation-rules-settings.type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=existing-content-validation-rules-settings.type.js.map

package/src/lib/types/existing-content-validation-rules-settings.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"existing-content-validation-rules-settings.type.js","sourceRoot":"","sources":["../../../../../../../packages/validation/src/lib/types/existing-content-validation-rules-settings.type.ts"],"names":[],"mappings":""}

package/src/lib/types/existing-content-validation-rules.type.d.ts

@@ -0,0 +1,9 @@
+import { AllowedValuesValidationRule } from "../validation-rules/allowed-values.validation-rule";
+import { CountValidationRule } from "../validation-rules/count.validation-rule";
+import { DateBetweenValidationRule } from "../validation-rules/date-between.validation-rule";
+import { DecimalCountValidationRule } from "../validation-rules/decimal-count.validation-rule";
+import { NumberBetweenValidationRule } from "../validation-rules/number-between.validation-rule";
+import { RelatableContentTypesValidationRule } from "../validation-rules/relatable-content-types.validation-rule";
+import { StringFormatValidationRule } from "../validation-rules/string-format.validation-rule";
+import { ValueTypeValidationRule } from "../validation-rules/value-type.validation-rule";
+export type ExistingContentValidationRules = AllowedValuesValidationRule | CountValidationRule | DateBetweenValidationRule | DecimalCountValidationRule | NumberBetweenValidationRule | RelatableContentTypesValidationRule | StringFormatValidationRule | ValueTypeValidationRule;

package/src/lib/types/existing-content-validation-rules.type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=existing-content-validation-rules.type.js.map

package/src/lib/types/existing-content-validation-rules.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"existing-content-validation-rules.type.js","sourceRoot":"","sources":["../../../../../../../packages/validation/src/lib/types/existing-content-validation-rules.type.ts"],"names":[],"mappings":""}

package/src/lib/types/rule-instance.interface.d.ts

@@ -0,0 +1,3 @@
+export interface RuleInstance<TRuleSettings> {
+    settings: TRuleSettings;
+}

package/src/lib/types/rule-instance.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=rule-instance.interface.js.map

package/src/lib/types/rule-instance.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-instance.interface.js","sourceRoot":"","sources":["../../../../../../../packages/validation/src/lib/types/rule-instance.interface.ts"],"names":[],"mappings":""}

package/src/lib/types/rule-types.enum.d.ts

@@ -0,0 +1,10 @@
+export declare enum RuleType {
+    ALLOWED_VALUES = "ALLOWED_VALUES",
+    COUNT = "COUNT",
+    DATE_BETWEEN = "DATE_BETWEEN",
+    DECIMAL_COUNT = "DECIMAL_COUNT",
+    NUMBER_BETWEEN = "NUMBER_BETWEEN",
+    RELATABLE_CONTENT_TYPES = "RELATABLE_CONTENT_TYPES",
+    STRING_FORMAT = "STRING_FORMAT",
+    VALUE_TYPE = "VALUE_TYPE"
+}

package/src/lib/types/rule-types.enum.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleType = void 0;
+var RuleType;
+(function (RuleType) {
+    RuleType["ALLOWED_VALUES"] = "ALLOWED_VALUES";
+    RuleType["COUNT"] = "COUNT";
+    RuleType["DATE_BETWEEN"] = "DATE_BETWEEN";
+    RuleType["DECIMAL_COUNT"] = "DECIMAL_COUNT";
+    RuleType["NUMBER_BETWEEN"] = "NUMBER_BETWEEN";
+    RuleType["RELATABLE_CONTENT_TYPES"] = "RELATABLE_CONTENT_TYPES";
+    RuleType["STRING_FORMAT"] = "STRING_FORMAT";
+    RuleType["VALUE_TYPE"] = "VALUE_TYPE";
+})(RuleType || (exports.RuleType = RuleType = {}));
+//# sourceMappingURL=rule-types.enum.js.map

package/src/lib/types/rule-types.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-types.enum.js","sourceRoot":"","sources":["../../../../../../../packages/validation/src/lib/types/rule-types.enum.ts"],"names":[],"mappings":";;;AAAA,IAAY,QASX;AATD,WAAY,QAAQ;IAClB,6CAAiC,CAAA;IACjC,2BAAe,CAAA;IACf,yCAA6B,CAAA;IAC7B,2CAA+B,CAAA;IAC/B,6CAAiC,CAAA;IACjC,+DAAmD,CAAA;IACnD,2CAA+B,CAAA;IAC/B,qCAAyB,CAAA;AAC3B,CAAC,EATW,QAAQ,wBAAR,QAAQ,QASnB"}

package/src/lib/types/unknown-validation-error-target.interface.d.ts

@@ -0,0 +1,5 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+export interface UnknownValidationErrorTarget {
+    [key: string]: unknown;
+    prn?: PRN;
+}

package/src/lib/types/unknown-validation-error-target.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=unknown-validation-error-target.interface.js.map

package/src/lib/types/unknown-validation-error-target.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown-validation-error-target.interface.js","sourceRoot":"","sources":["../../../../../../../packages/validation/src/lib/types/unknown-validation-error-target.interface.ts"],"names":[],"mappings":""}

package/src/lib/validation-rules/allowed-values.validation-rule.d.ts

@@ -0,0 +1,12 @@
+import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
+import { RuleType } from "../types/rule-types.enum";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { ContentValueType } from "@platecms/delta-types";
+export declare const validateAllowedValues: <TRuleInstance extends RuleInstance<AllowedValuesValidationRuleSettings> = RuleInstance<AllowedValuesValidationRuleSettings>>(values: ContentValueType[], ruleInstance: TRuleInstance) => ContentValidationResultType[];
+export declare class AllowedValuesValidationRule extends BaseValidationRule<AllowedValuesValidationRuleSettings> {
+    readonly ruleType: RuleType;
+    validate(values: ContentValueType[]): ContentValidationResultType[];
+}
+export interface AllowedValuesValidationRuleSettings {
+    allowedValues: ContentValueType[];
+}

package/src/lib/validation-rules/allowed-values.validation-rule.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllowedValuesValidationRule = exports.validateAllowedValues = void 0;
+const base_validation_rule_1 = require("./base.validation-rule");
+const rule_types_enum_1 = require("../types/rule-types.enum");
+const content_validation_error_detail_1 = require("../errors/content-validation-error-detail");
+const validation_rule_function_factory_1 = require("./validation-rule-function.factory");
+const delta_plate_resource_notation_1 = require("@platecms/delta-plate-resource-notation");
+function validateValueAllowedValues(value, ruleInstance) {
+    const valid = ruleInstance.settings.allowedValues.some((allowedValue) => {
+        if (value instanceof delta_plate_resource_notation_1.PRN) {
+            return allowedValue instanceof delta_plate_resource_notation_1.PRN && value.equals(allowedValue);
+        }
+        if (value instanceof Date) {
+            return allowedValue instanceof Date && value.getTime() === allowedValue.getTime();
+        }
+        return value === allowedValue;
+    });
+    if (!valid) {
+        return new content_validation_error_detail_1.ContentValidationErrorDetail(`The provided value must be one of ${ruleInstance.settings.allowedValues.join(", ")}`, ruleInstance);
+    }
+    return true;
+}
+exports.validateAllowedValues = (0, validation_rule_function_factory_1.validationFunctionFromValidateValue)(validateValueAllowedValues);
+class AllowedValuesValidationRule extends base_validation_rule_1.BaseValidationRule {
+    constructor() {
+        super(...arguments);
+        this.ruleType = rule_types_enum_1.RuleType.ALLOWED_VALUES;
+    }
+    validate(values) {
+        return (0, exports.validateAllowedValues)(values, this);
+    }
+}
+exports.AllowedValuesValidationRule = AllowedValuesValidationRule;
+//# sourceMappingURL=allowed-values.validation-rule.js.map

package/src/lib/validation-rules/allowed-values.validation-rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"allowed-values.validation-rule.js","sourceRoot":"","sources":["../../../../../../../packages/validation/src/lib/validation-rules/allowed-values.validation-rule.ts"],"names":[],"mappings":";;;AAAA,iEAAyF;AACzF,8DAAoD;AACpD,+FAAyF;AAEzF,yFAAyF;AAEzF,2FAA8D;AAE9D,SAAS,0BAA0B,CACjC,KAAuB,EACvB,YAA+D;IAE/D,MAAM,KAAK,GAAG,YAAY,CAAC,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,EAAE;QACtE,IAAI,KAAK,YAAY,mCAAG,EAAE,CAAC;YACzB,OAAO,YAAY,YAAY,mCAAG,IAAI,KAAK,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QACnE,CAAC;QAED,IAAI,KAAK,YAAY,IAAI,EAAE,CAAC;YAC1B,OAAO,YAAY,YAAY,IAAI,IAAI,KAAK,CAAC,OAAO,EAAE,KAAK,YAAY,CAAC,OAAO,EAAE,CAAC;QACpF,CAAC;QAED,OAAO,KAAK,KAAK,YAAY,CAAC;IAChC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,IAAI,8DAA4B,CACrC,qCAAqC,YAAY,CAAC,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EACrF,YAAY,CACb,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAGY,QAAA,qBAAqB,GAAG,IAAA,sEAAmC,EAAC,0BAA0B,CAAC,CAAC;AAMrG,MAAa,2BAA4B,SAAQ,yCAAuD;IAAxG;;QACkB,aAAQ,GAAa,0BAAQ,CAAC,cAAc,CAAC;IAK/D,CAAC;IAHiB,QAAQ,CAAC,MAA0B;QACjD,OAAO,IAAA,6BAAqB,EAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC7C,CAAC;CACF;AAND,kEAMC"}

package/src/lib/validation-rules/base.validation-rule.d.ts

@@ -0,0 +1,13 @@
+import { RuleType } from "../types/rule-types.enum";
+import { ContentValidationErrorDetail } from "../errors/content-validation-error-detail";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueType } from "@platecms/delta-types";
+export type ContentValidationResultType<TRuleInstance extends RuleInstance<unknown> = RuleInstance<unknown>> = ContentValidationErrorDetail<TRuleInstance> | true | null;
+export declare abstract class BaseValidationRule<TSettings> implements RuleInstance<TSettings> {
+    readonly prn: PRN;
+    readonly settings: TSettings;
+    abstract readonly ruleType: RuleType;
+    constructor(prn: PRN, settings: TSettings);
+    validate(_: ContentValueType[]): ContentValidationResultType[];
+}

package/src/lib/validation-rules/base.validation-rule.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseValidationRule = void 0;
+class BaseValidationRule {
+    constructor(prn, settings) {
+        this.prn = prn;
+        this.settings = settings;
+    }
+    validate(_) {
+        throw new Error("validate method must be overridden.");
+    }
+}
+exports.BaseValidationRule = BaseValidationRule;
+//# sourceMappingURL=base.validation-rule.js.map

package/src/lib/validation-rules/base.validation-rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.validation-rule.js","sourceRoot":"","sources":["../../../../../../../packages/validation/src/lib/validation-rules/base.validation-rule.ts"],"names":[],"mappings":";;;AAWA,MAAsB,kBAAkB;IAOtC,YAAmB,GAAQ,EAAE,QAAmB;QAC9C,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAUM,QAAQ,CAAC,CAAqB;QACnC,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;IACzD,CAAC;CACF;AAvBD,gDAuBC"}

package/src/lib/validation-rules/count.validation-rule.d.ts

@@ -0,0 +1,15 @@
+import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
+import { RuleType } from "../types/rule-types.enum";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueType } from "@platecms/delta-types";
+export declare function validateCount(values: ContentValueType[], ruleInstance: RuleInstance<CountValidationRuleSettings>): ContentValidationResultType[];
+export declare class CountValidationRule extends BaseValidationRule<CountValidationRuleSettings> {
+    readonly ruleType: RuleType;
+    constructor(prn: PRN, settings: CountValidationRuleSettings);
+    validate(value: ContentValueType[]): ContentValidationResultType[];
+}
+export interface CountValidationRuleSettings {
+    min?: number;
+    max?: number;
+}

package/src/lib/validation-rules/count.validation-rule.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CountValidationRule = void 0;
+exports.validateCount = validateCount;
+const invalid_content_validation_error_1 = require("../invalid-content-validation.error");
+const base_validation_rule_1 = require("./base.validation-rule");
+const rule_types_enum_1 = require("../types/rule-types.enum");
+const content_validation_error_detail_1 = require("../errors/content-validation-error-detail");
+function validateCount(values, ruleInstance) {
+    if (ruleInstance.settings.min != null && values.length < ruleInstance.settings.min) {
+        return [
+            new content_validation_error_detail_1.ContentValidationErrorDetail(`The amount of provided values must be greater than or equal ${ruleInstance.settings.min}.`, ruleInstance),
+        ];
+    }
+    if (ruleInstance.settings.max != null && values.length > ruleInstance.settings.max) {
+        return [
+            new content_validation_error_detail_1.ContentValidationErrorDetail(`The amount of provided values must be be less than or equal ${ruleInstance.settings.max}.`, ruleInstance),
+        ];
+    }
+    return [true];
+}
+class CountValidationRule extends base_validation_rule_1.BaseValidationRule {
+    constructor(prn, settings) {
+        if (settings.min == null && settings.max == null) {
+            throw new invalid_content_validation_error_1.InvalidContentValidationError("Either min or max must be defined.");
+        }
+        super(prn, settings);
+        this.ruleType = rule_types_enum_1.RuleType.COUNT;
+    }
+    validate(value) {
+        return validateCount(value, this);
+    }
+}
+exports.CountValidationRule = CountValidationRule;
+//# sourceMappingURL=count.validation-rule.js.map

package/src/lib/validation-rules/count.validation-rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"count.validation-rule.js","sourceRoot":"","sources":["../../../../../../../packages/validation/src/lib/validation-rules/count.validation-rule.ts"],"names":[],"mappings":";;;AAQA,sCAqBC;AA7BD,0FAAoF;AACpF,iEAAyF;AACzF,8DAAoD;AACpD,+FAAyF;AAKzF,SAAgB,aAAa,CAC3B,MAA0B,EAC1B,YAAuD;IAEvD,IAAI,YAAY,CAAC,QAAQ,CAAC,GAAG,IAAI,IAAI,IAAI,MAAM,CAAC,MAAM,GAAG,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;QACnF,OAAO;YACL,IAAI,8DAA4B,CAC9B,+DAA+D,YAAY,CAAC,QAAQ,CAAC,GAAG,GAAG,EAC3F,YAAY,CACb;SACF,CAAC;IACJ,CAAC;IACD,IAAI,YAAY,CAAC,QAAQ,CAAC,GAAG,IAAI,IAAI,IAAI,MAAM,CAAC,MAAM,GAAG,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;QACnF,OAAO;YACL,IAAI,8DAA4B,CAC9B,+DAA+D,YAAY,CAAC,QAAQ,CAAC,GAAG,GAAG,EAC3F,YAAY,CACb;SACF,CAAC;IACJ,CAAC;IACD,OAAO,CAAC,IAAI,CAAC,CAAC;AAChB,CAAC;AAKD,MAAa,mBAAoB,SAAQ,yCAA+C;IAGtF,YAAmB,GAAQ,EAAE,QAAqC;QAChE,IAAI,QAAQ,CAAC,GAAG,IAAI,IAAI,IAAI,QAAQ,CAAC,GAAG,IAAI,IAAI,EAAE,CAAC;YACjD,MAAM,IAAI,gEAA6B,CAAC,oCAAoC,CAAC,CAAC;QAChF,CAAC;QACD,KAAK,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QANP,aAAQ,GAAa,0BAAQ,CAAC,KAAK,CAAC;IAOpD,CAAC;IAEe,QAAQ,CAAC,KAAyB;QAChD,OAAO,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACpC,CAAC;CACF;AAbD,kDAaC"}

package/src/lib/validation-rules/date-between.validation-rule.d.ts

@@ -0,0 +1,15 @@
+import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
+import { RuleType } from "../types/rule-types.enum";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueType } from "@platecms/delta-types";
+export declare const validateDateBetween: <TRuleInstance extends RuleInstance<DateBetweenValidationRuleSettings> = RuleInstance<DateBetweenValidationRuleSettings>>(values: ContentValueType[], ruleInstance: TRuleInstance) => ContentValidationResultType[];
+export declare class DateBetweenValidationRule extends BaseValidationRule<DateBetweenValidationRuleSettings> {
+    readonly ruleType: RuleType;
+    constructor(prn: PRN, settings: DateBetweenValidationRuleSettings);
+    validate(values: ContentValueType[]): ContentValidationResultType[];
+}
+export interface DateBetweenValidationRuleSettings {
+    min?: Date;
+    max?: Date;
+}

package/src/lib/validation-rules/date-between.validation-rule.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateBetweenValidationRule = exports.validateDateBetween = void 0;
+const invalid_content_validation_error_1 = require("../invalid-content-validation.error");
+const base_validation_rule_1 = require("./base.validation-rule");
+const rule_types_enum_1 = require("../types/rule-types.enum");
+const content_validation_error_detail_1 = require("../errors/content-validation-error-detail");
+const validation_rule_function_factory_1 = require("./validation-rule-function.factory");
+function validateValueDateBetween(value, ruleInstance) {
+    if (!(value instanceof Date)) {
+        return null;
+    }
+    if (ruleInstance.settings.min != null && value < ruleInstance.settings.min) {
+        return new content_validation_error_detail_1.ContentValidationErrorDetail(`The date must be greater than or equal ${ruleInstance.settings.min.toDateString()}`, ruleInstance);
+    }
+    if (ruleInstance.settings.max != null && value > ruleInstance.settings.max) {
+        return new content_validation_error_detail_1.ContentValidationErrorDetail(`The date must be lower than or equal ${ruleInstance.settings.max.toDateString()}`, ruleInstance);
+    }
+    return true;
+}
+exports.validateDateBetween = (0, validation_rule_function_factory_1.validationFunctionFromValidateValue)(validateValueDateBetween);
+class DateBetweenValidationRule extends base_validation_rule_1.BaseValidationRule {
+    constructor(prn, settings) {
+        if (settings.min == null && settings.max == null) {
+            throw new invalid_content_validation_error_1.InvalidContentValidationError("Either min or max must be defined.");
+        }
+        super(prn, settings);
+        this.ruleType = rule_types_enum_1.RuleType.DATE_BETWEEN;
+    }
+    validate(values) {
+        return (0, exports.validateDateBetween)(values, this);
+    }
+}
+exports.DateBetweenValidationRule = DateBetweenValidationRule;
+//# sourceMappingURL=date-between.validation-rule.js.map

package/src/lib/validation-rules/date-between.validation-rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-between.validation-rule.js","sourceRoot":"","sources":["../../../../../../../packages/validation/src/lib/validation-rules/date-between.validation-rule.ts"],"names":[],"mappings":";;;AAAA,0FAAoF;AACpF,iEAAyF;AACzF,8DAAoD;AACpD,+FAAyF;AAEzF,yFAAyF;AAIzF,SAAS,wBAAwB,CAC/B,KAAuB,EACvB,YAA6D;IAE7D,IAAI,CAAC,CAAC,KAAK,YAAY,IAAI,CAAC,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,YAAY,CAAC,QAAQ,CAAC,GAAG,IAAI,IAAI,IAAI,KAAK,GAAG,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;QAC3E,OAAO,IAAI,8DAA4B,CACrC,0CAA0C,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,YAAY,EAAE,EAAE,EACpF,YAAY,CACb,CAAC;IACJ,CAAC;IACD,IAAI,YAAY,CAAC,QAAQ,CAAC,GAAG,IAAI,IAAI,IAAI,KAAK,GAAG,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;QAC3E,OAAO,IAAI,8DAA4B,CACrC,wCAAwC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,YAAY,EAAE,EAAE,EAClF,YAAY,CACb,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAGY,QAAA,mBAAmB,GAAG,IAAA,sEAAmC,EAAC,wBAAwB,CAAC,CAAC;AAEjG,MAAa,yBAA0B,SAAQ,yCAAqD;IAGlG,YAAmB,GAAQ,EAAE,QAA2C;QACtE,IAAI,QAAQ,CAAC,GAAG,IAAI,IAAI,IAAI,QAAQ,CAAC,GAAG,IAAI,IAAI,EAAE,CAAC;YACjD,MAAM,IAAI,gEAA6B,CAAC,oCAAoC,CAAC,CAAC;QAChF,CAAC;QACD,KAAK,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QANP,aAAQ,GAAa,0BAAQ,CAAC,YAAY,CAAC;IAO3D,CAAC;IAEe,QAAQ,CAAC,MAA0B;QACjD,OAAO,IAAA,2BAAmB,EAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC3C,CAAC;CACF;AAbD,8DAaC"}

package/src/lib/validation-rules/decimal-count.validation-rule.d.ts

@@ -0,0 +1,12 @@
+import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
+import { RuleType } from "../types/rule-types.enum";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { ContentValueType } from "@platecms/delta-types";
+export declare const validateDecimalCount: <TRuleInstance extends RuleInstance<DecimalCountValidationRuleSettings> = RuleInstance<DecimalCountValidationRuleSettings>>(values: ContentValueType[], ruleInstance: TRuleInstance) => ContentValidationResultType[];
+export declare class DecimalCountValidationRule extends BaseValidationRule<DecimalCountValidationRuleSettings> {
+    readonly ruleType: RuleType;
+    validate(values: ContentValueType[]): ContentValidationResultType[];
+}
+export interface DecimalCountValidationRuleSettings {
+    max: number;
+}

package/src/lib/validation-rules/decimal-count.validation-rule.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecimalCountValidationRule = exports.validateDecimalCount = void 0;
+const base_validation_rule_1 = require("./base.validation-rule");
+const rule_types_enum_1 = require("../types/rule-types.enum");
+const content_validation_error_detail_1 = require("../errors/content-validation-error-detail");
+const validation_rule_function_factory_1 = require("./validation-rule-function.factory");
+function getDecimalCount(value) {
+    const [_, decimalDigits] = value.toString().split(".");
+    return decimalDigits ? decimalDigits.length : 0;
+}
+function validateValueDecimalCount(value, ruleInstance) {
+    if (typeof value !== "number") {
+        return null;
+    }
+    const decimalCount = getDecimalCount(value);
+    if (decimalCount > ruleInstance.settings.max) {
+        return new content_validation_error_detail_1.ContentValidationErrorDetail(`The number must not have more than ${ruleInstance.settings.max} decimals`, ruleInstance);
+    }
+    return true;
+}
+exports.validateDecimalCount = (0, validation_rule_function_factory_1.validationFunctionFromValidateValue)(validateValueDecimalCount);
+class DecimalCountValidationRule extends base_validation_rule_1.BaseValidationRule {
+    constructor() {
+        super(...arguments);
+        this.ruleType = rule_types_enum_1.RuleType.DECIMAL_COUNT;
+    }
+    validate(values) {
+        return (0, exports.validateDecimalCount)(values, this);
+    }
+}
+exports.DecimalCountValidationRule = DecimalCountValidationRule;
+//# sourceMappingURL=decimal-count.validation-rule.js.map

package/src/lib/validation-rules/decimal-count.validation-rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimal-count.validation-rule.js","sourceRoot":"","sources":["../../../../../../../packages/validation/src/lib/validation-rules/decimal-count.validation-rule.ts"],"names":[],"mappings":";;;AAAA,iEAAyF;AACzF,8DAAoD;AACpD,+FAAyF;AAEzF,yFAAyF;AAGzF,SAAS,eAAe,CAAC,KAAa;IACpC,MAAM,CAAC,CAAC,EAAE,aAAa,CAAC,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACvD,OAAO,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAClD,CAAC;AAED,SAAS,yBAAyB,CAChC,KAAuB,EACvB,YAA8D;IAE9D,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,YAAY,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC;IAE5C,IAAI,YAAY,GAAG,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;QAC7C,OAAO,IAAI,8DAA4B,CACrC,sCAAsC,YAAY,CAAC,QAAQ,CAAC,GAAG,WAAW,EAC1E,YAAY,CACb,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAGY,QAAA,oBAAoB,GAAG,IAAA,sEAAmC,EAAC,yBAAyB,CAAC,CAAC;AAQnG,MAAa,0BAA2B,SAAQ,yCAAsD;IAAtG;;QACkB,aAAQ,GAAa,0BAAQ,CAAC,aAAa,CAAC;IAK9D,CAAC;IAHiB,QAAQ,CAAC,MAA0B;QACjD,OAAO,IAAA,4BAAoB,EAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC5C,CAAC;CACF;AAND,gEAMC"}

package/src/lib/validation-rules/number-between.validation-rule.d.ts

@@ -0,0 +1,15 @@
+import { RuleInstance } from "../types/rule-instance.interface";
+import { RuleType } from "../types/rule-types.enum";
+import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueType } from "@platecms/delta-types";
+export declare const validateNumberBetween: <TRuleInstance extends RuleInstance<NumberBetweenValidationRuleSettings> = RuleInstance<NumberBetweenValidationRuleSettings>>(values: ContentValueType[], ruleInstance: TRuleInstance) => ContentValidationResultType[];
+export declare class NumberBetweenValidationRule extends BaseValidationRule<NumberBetweenValidationRuleSettings> {
+    readonly ruleType: RuleType;
+    constructor(prn: PRN, settings: NumberBetweenValidationRuleSettings);
+    validate(values: ContentValueType[]): ContentValidationResultType[];
+}
+export interface NumberBetweenValidationRuleSettings {
+    min?: number;
+    max?: number;
+}

package/src/lib/validation-rules/number-between.validation-rule.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberBetweenValidationRule = exports.validateNumberBetween = void 0;
+const content_validation_error_detail_1 = require("../errors/content-validation-error-detail");
+const invalid_content_validation_error_1 = require("../invalid-content-validation.error");
+const rule_types_enum_1 = require("../types/rule-types.enum");
+const base_validation_rule_1 = require("./base.validation-rule");
+const validation_rule_function_factory_1 = require("./validation-rule-function.factory");
+function validateValueNumberBetween(value, ruleInstance) {
+    if (typeof value !== "number") {
+        return null;
+    }
+    if (ruleInstance.settings.min != null && value < ruleInstance.settings.min) {
+        return new content_validation_error_detail_1.ContentValidationErrorDetail(`The value must be greater than or equal ${ruleInstance.settings.min}`, ruleInstance);
+    }
+    if (ruleInstance.settings.max != null && value > ruleInstance.settings.max) {
+        return new content_validation_error_detail_1.ContentValidationErrorDetail(`The value must be less than or equal ${ruleInstance.settings.max}`, ruleInstance);
+    }
+    return true;
+}
+exports.validateNumberBetween = (0, validation_rule_function_factory_1.validationFunctionFromValidateValue)(validateValueNumberBetween);
+class NumberBetweenValidationRule extends base_validation_rule_1.BaseValidationRule {
+    constructor(prn, settings) {
+        if (settings.min == null && settings.max == null) {
+            throw new invalid_content_validation_error_1.InvalidContentValidationError("Either min or max must be defined.");
+        }
+        super(prn, settings);
+        this.ruleType = rule_types_enum_1.RuleType.NUMBER_BETWEEN;
+    }
+    validate(values) {
+        return (0, exports.validateNumberBetween)(values, this);
+    }
+}
+exports.NumberBetweenValidationRule = NumberBetweenValidationRule;
+//# sourceMappingURL=number-between.validation-rule.js.map

package/src/lib/validation-rules/number-between.validation-rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-between.validation-rule.js","sourceRoot":"","sources":["../../../../../../../packages/validation/src/lib/validation-rules/number-between.validation-rule.ts"],"names":[],"mappings":";;;AAAA,+FAAyF;AAEzF,0FAAoF;AACpF,8DAAoD;AACpD,iEAAyF;AACzF,yFAAyF;AAIzF,SAAS,0BAA0B,CACjC,KAAuB,EACvB,YAA+D;IAE/D,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,YAAY,CAAC,QAAQ,CAAC,GAAG,IAAI,IAAI,IAAI,KAAK,GAAG,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;QAC3E,OAAO,IAAI,8DAA4B,CACrC,2CAA2C,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,EACtE,YAAY,CACb,CAAC;IACJ,CAAC;IACD,IAAI,YAAY,CAAC,QAAQ,CAAC,GAAG,IAAI,IAAI,IAAI,KAAK,GAAG,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;QAC3E,OAAO,IAAI,8DAA4B,CACrC,wCAAwC,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,EACnE,YAAY,CACb,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAGY,QAAA,qBAAqB,GAAG,IAAA,sEAAmC,EAAC,0BAA0B,CAAC,CAAC;AAKrG,MAAa,2BAA4B,SAAQ,yCAAuD;IAGtG,YAAmB,GAAQ,EAAE,QAA6C;QACxE,IAAI,QAAQ,CAAC,GAAG,IAAI,IAAI,IAAI,QAAQ,CAAC,GAAG,IAAI,IAAI,EAAE,CAAC;YACjD,MAAM,IAAI,gEAA6B,CAAC,oCAAoC,CAAC,CAAC;QAChF,CAAC;QACD,KAAK,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QANP,aAAQ,GAAa,0BAAQ,CAAC,cAAc,CAAC;IAO7D,CAAC;IAEe,QAAQ,CAAC,MAA0B;QACjD,OAAO,IAAA,6BAAqB,EAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC7C,CAAC;CACF;AAbD,kEAaC"}

package/src/lib/validation-rules/relatable-content-types.validation-rule.d.ts

@@ -0,0 +1,13 @@
+import { RuleInstance } from "../types/rule-instance.interface";
+import { RuleType } from "../types/rule-types.enum";
+import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
+import { ContentValueType } from "@platecms/delta-types";
+import { PRN } from "@platecms/delta-plate-resource-notation";
+export declare function validateRelatableContentTypes<TContentType>(values: ContentValueType[], ruleInstance: RuleInstance<RelatableContentTypesValidationRuleSettings<TContentType>>, contentTypes: TContentType[]): ContentValidationResultType[];
+export declare class RelatableContentTypesValidationRule extends BaseValidationRule<RelatableContentTypesValidationRuleSettings<PRN>> {
+    readonly ruleType: RuleType;
+    validate(values: ContentValueType[], contentTypes?: PRN[]): ContentValidationResultType[];
+}
+export interface RelatableContentTypesValidationRuleSettings<TContentType> {
+    allowedContentTypes: TContentType[];
+}

package/src/lib/validation-rules/relatable-content-types.validation-rule.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelatableContentTypesValidationRule = void 0;
+exports.validateRelatableContentTypes = validateRelatableContentTypes;
+const content_validation_error_detail_1 = require("../errors/content-validation-error-detail");
+const invalid_content_validation_validate_args_error_1 = require("../invalid-content-validation-validate-args.error");
+const rule_types_enum_1 = require("../types/rule-types.enum");
+const base_validation_rule_1 = require("./base.validation-rule");
+function validateValueRelatableContentTypes(value, contentType, ruleInstance) {
+    if (contentType === undefined) {
+        throw new invalid_content_validation_validate_args_error_1.InvalidContentValidationValidateArgsError(`Missing attribute 'contentType' for value: ${JSON.stringify(value)}`);
+    }
+    if (!ruleInstance.settings.allowedContentTypes.includes(contentType)) {
+        return new content_validation_error_detail_1.ContentValidationErrorDetail(`The provided content type must be type of ${ruleInstance.settings.allowedContentTypes.join(", ")}`, ruleInstance);
+    }
+    return true;
+}
+function validateRelatableContentTypes(values, ruleInstance, contentTypes) {
+    if (values.length !== contentTypes.length) {
+        throw new invalid_content_validation_validate_args_error_1.InvalidContentValidationValidateArgsError(`The length of values and contentTypes must be equal.`);
+    }
+    return values.map((value, index) => validateValueRelatableContentTypes(value, contentTypes[index], ruleInstance));
+}
+class RelatableContentTypesValidationRule extends base_validation_rule_1.BaseValidationRule {
+    constructor() {
+        super(...arguments);
+        this.ruleType = rule_types_enum_1.RuleType.RELATABLE_CONTENT_TYPES;
+    }
+    validate(values, contentTypes) {
+        if (contentTypes === undefined) {
+            throw new invalid_content_validation_validate_args_error_1.InvalidContentValidationValidateArgsError(`Missing attribute 'contentTypes' in values: ${JSON.stringify(values)}`);
+        }
+        return validateRelatableContentTypes(values, this, contentTypes);
+    }
+}
+exports.RelatableContentTypesValidationRule = RelatableContentTypesValidationRule;
+//# sourceMappingURL=relatable-content-types.validation-rule.js.map

package/src/lib/validation-rules/relatable-content-types.validation-rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relatable-content-types.validation-rule.js","sourceRoot":"","sources":["../../../../../../../packages/validation/src/lib/validation-rules/relatable-content-types.validation-rule.ts"],"names":[],"mappings":";;;AA6BA,sEAUC;AAvCD,+FAAyF;AAEzF,sHAA8G;AAC9G,8DAAoD;AACpD,iEAAyF;AAIzF,SAAS,kCAAkC,CACzC,KAAuB,EACvB,WAAyB,EACzB,YAAqF;IAErF,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;QAC9B,MAAM,IAAI,0FAAyC,CACjD,8CAA8C,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CACtE,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,mBAAmB,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;QACrE,OAAO,IAAI,8DAA4B,CACrC,6CAA6C,YAAY,CAAC,QAAQ,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EACnG,YAAY,CACb,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAgB,6BAA6B,CAC3C,MAA0B,EAC1B,YAAqF,EACrF,YAA4B;IAE5B,IAAI,MAAM,CAAC,MAAM,KAAK,YAAY,CAAC,MAAM,EAAE,CAAC;QAC1C,MAAM,IAAI,0FAAyC,CAAC,sDAAsD,CAAC,CAAC;IAC9G,CAAC;IAED,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,kCAAkC,CAAC,KAAK,EAAE,YAAY,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC;AACpH,CAAC;AAKD,MAAa,mCAAoC,SAAQ,yCAExD;IAFD;;QAGkB,aAAQ,GAAa,0BAAQ,CAAC,uBAAuB,CAAC;IAWxE,CAAC;IATiB,QAAQ,CAAC,MAA0B,EAAE,YAAoB;QACvE,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;YAC/B,MAAM,IAAI,0FAAyC,CACjD,+CAA+C,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CACxE,CAAC;QACJ,CAAC;QAED,OAAO,6BAA6B,CAAC,MAAM,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;IACnE,CAAC;CACF;AAdD,kFAcC"}

package/src/lib/validation-rules/string-format.validation-rule.d.ts

@@ -0,0 +1,13 @@
+import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
+import { RuleType } from "../types/rule-types.enum";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { ContentValueType } from "@platecms/delta-types";
+export declare function validateValueStringFormat(value: ContentValueType, ruleInstance: RuleInstance<StringFormatValidationRuleSettings>): ContentValidationResultType;
+export declare const validateStringFormat: <TRuleInstance extends RuleInstance<StringFormatValidationRuleSettings> = RuleInstance<StringFormatValidationRuleSettings>>(values: ContentValueType[], ruleInstance: TRuleInstance) => ContentValidationResultType[];
+export declare class StringFormatValidationRule extends BaseValidationRule<StringFormatValidationRuleSettings> {
+    readonly ruleType: RuleType;
+    validate(values: ContentValueType[]): ContentValidationResultType[];
+}
+export interface StringFormatValidationRuleSettings {
+    allowedFormat: string;
+}

package/src/lib/validation-rules/string-format.validation-rule.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringFormatValidationRule = exports.validateStringFormat = void 0;
+exports.validateValueStringFormat = validateValueStringFormat;
+const base_validation_rule_1 = require("./base.validation-rule");
+const rule_types_enum_1 = require("../types/rule-types.enum");
+const content_validation_error_detail_1 = require("../errors/content-validation-error-detail");
+const validation_rule_function_factory_1 = require("./validation-rule-function.factory");
+function validateValueStringFormat(value, ruleInstance) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const regex = new RegExp(ruleInstance.settings.allowedFormat);
+    if (!regex.test(value)) {
+        return new content_validation_error_detail_1.ContentValidationErrorDetail(`The value field is invalid`, ruleInstance);
+    }
+    return true;
+}
+exports.validateStringFormat = (0, validation_rule_function_factory_1.validationFunctionFromValidateValue)(validateValueStringFormat);
+class StringFormatValidationRule extends base_validation_rule_1.BaseValidationRule {
+    constructor() {
+        super(...arguments);
+        this.ruleType = rule_types_enum_1.RuleType.STRING_FORMAT;
+    }
+    validate(values) {
+        return (0, exports.validateStringFormat)(values, this);
+    }
+}
+exports.StringFormatValidationRule = StringFormatValidationRule;
+//# sourceMappingURL=string-format.validation-rule.js.map

package/src/lib/validation-rules/string-format.validation-rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-format.validation-rule.js","sourceRoot":"","sources":["../../../../../../../packages/validation/src/lib/validation-rules/string-format.validation-rule.ts"],"names":[],"mappings":";;;AAQA,8DAiBC;AAzBD,iEAAyF;AACzF,8DAAoD;AACpD,+FAAyF;AAEzF,yFAAyF;AAIzF,SAAgB,yBAAyB,CACvC,KAAuB,EACvB,YAA8D;IAE9D,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAGD,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;IAE9D,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QAEvB,OAAO,IAAI,8DAA4B,CAAC,4BAA4B,EAAE,YAAY,CAAC,CAAC;IACtF,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAGY,QAAA,oBAAoB,GAAG,IAAA,sEAAmC,EAAC,yBAAyB,CAAC,CAAC;AAKnG,MAAa,0BAA2B,SAAQ,yCAAsD;IAAtG;;QACkB,aAAQ,GAAa,0BAAQ,CAAC,aAAa,CAAC;IAK9D,CAAC;IAHiB,QAAQ,CAAC,MAA0B;QACjD,OAAO,IAAA,4BAAoB,EAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC5C,CAAC;CACF;AAND,gEAMC"}

package/src/lib/validation-rules/validation-rule-function.factory.d.ts

@@ -0,0 +1,4 @@
+import { RuleInstance } from "../types/rule-instance.interface";
+import { ContentValidationResultType } from "./base.validation-rule";
+import { ContentValueType } from "@platecms/delta-types";
+export declare function validationFunctionFromValidateValue<TRuleInstanceSettings>(validateValue: (value: ContentValueType, ruleInstance: RuleInstance<TRuleInstanceSettings>) => ContentValidationResultType): <TRuleInstance extends RuleInstance<TRuleInstanceSettings> = RuleInstance<TRuleInstanceSettings>>(values: ContentValueType[], ruleInstance: TRuleInstance) => ContentValidationResultType[];

package/src/lib/validation-rules/validation-rule-function.factory.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validationFunctionFromValidateValue = validationFunctionFromValidateValue;
+function validationFunctionFromValidateValue(validateValue) {
+    return function validate(values, ruleInstance) {
+        return values.map((value) => validateValue(value, ruleInstance));
+    };
+}
+//# sourceMappingURL=validation-rule-function.factory.js.map

package/src/lib/validation-rules/validation-rule-function.factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-rule-function.factory.js","sourceRoot":"","sources":["../../../../../../../packages/validation/src/lib/validation-rules/validation-rule-function.factory.ts"],"names":[],"mappings":";;AAWA,kFAWC;AAXD,SAAgB,mCAAmC,CACjD,aAGgC;IAEhC,OAAO,SAAS,QAAQ,CAEtB,MAA0B,EAAE,YAA2B;QACvD,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,aAAa,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC;IACnE,CAAC,CAAC;AACJ,CAAC"}

package/src/lib/validation-rules/value-type.validation-rule.d.ts

@@ -0,0 +1,13 @@
+import { RuleInstance } from "../types/rule-instance.interface";
+import { RuleType } from "../types/rule-types.enum";
+import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
+import { ContentValueType, ContentValueTypeName } from "@platecms/delta-types";
+export declare function validateValueValueType(value: ContentValueType, ruleInstance: RuleInstance<ValueTypeValidationRuleSettings>): ContentValidationResultType;
+export declare const validateValueType: <TRuleInstance extends RuleInstance<ValueTypeValidationRuleSettings> = RuleInstance<ValueTypeValidationRuleSettings>>(values: ContentValueType[], ruleInstance: TRuleInstance) => ContentValidationResultType[];
+export declare class ValueTypeValidationRule extends BaseValidationRule<ValueTypeValidationRuleSettings> {
+    readonly ruleType: RuleType;
+    validate(values: ContentValueType[]): ContentValidationResultType[];
+}
+export interface ValueTypeValidationRuleSettings {
+    allowedTypes: ContentValueTypeName<ContentValueType>[];
+}

package/src/lib/validation-rules/value-type.validation-rule.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueTypeValidationRule = exports.validateValueType = void 0;
+exports.validateValueValueType = validateValueValueType;
+const content_validation_error_detail_1 = require("../errors/content-validation-error-detail");
+const rule_types_enum_1 = require("../types/rule-types.enum");
+const base_validation_rule_1 = require("./base.validation-rule");
+const validation_rule_function_factory_1 = require("./validation-rule-function.factory");
+const delta_cast_1 = require("@platecms/delta-cast");
+const delta_types_1 = require("@platecms/delta-types");
+const delta_plate_resource_notation_1 = require("@platecms/delta-plate-resource-notation");
+const prnResourceTypeToContentValueTypeNameMap = {
+    "content-item": delta_types_1.ContentValueTypeNames.CONTENT_ITEM,
+    asset: delta_types_1.ContentValueTypeNames.ASSET,
+    "path-part": delta_types_1.ContentValueTypeNames.PATH_PART,
+    "grid-placement": delta_types_1.ContentValueTypeNames.GRID_PLACEMENT,
+};
+function validateValueValueType(value, ruleInstance) {
+    if (value instanceof Date && ruleInstance.settings.allowedTypes.includes(delta_types_1.ContentValueTypeNames.DATE)) {
+        return true;
+    }
+    try {
+        (0, delta_cast_1.validateCast)(value);
+        if (ruleInstance.settings.allowedTypes.includes(delta_types_1.ContentValueTypeNames.SMART_TEXT)) {
+            return true;
+        }
+    }
+    catch (error) {
+        if (!(error instanceof delta_cast_1.InvalidCastError)) {
+            throw error;
+        }
+    }
+    if (value instanceof delta_plate_resource_notation_1.PRN &&
+        ruleInstance.settings.allowedTypes.includes(prnResourceTypeToContentValueTypeNameMap[value.resourceType])) {
+        return true;
+    }
+    if (ruleInstance.settings.allowedTypes.includes((typeof value).toUpperCase())) {
+        return true;
+    }
+    return new content_validation_error_detail_1.ContentValidationErrorDetail(`The value must be of the correct type.`, ruleInstance);
+}
+exports.validateValueType = (0, validation_rule_function_factory_1.validationFunctionFromValidateValue)(validateValueValueType);
+class ValueTypeValidationRule extends base_validation_rule_1.BaseValidationRule {
+    constructor() {
+        super(...arguments);
+        this.ruleType = rule_types_enum_1.RuleType.VALUE_TYPE;
+    }
+    validate(values) {
+        return (0, exports.validateValueType)(values, this);
+    }
+}
+exports.ValueTypeValidationRule = ValueTypeValidationRule;
+//# sourceMappingURL=value-type.validation-rule.js.map