@nascentdigital/funnel-core 4.4.4

package/dist/ui/fields/validators/EnumValidator.js

@@ -0,0 +1,77 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumValidator = void 0;
+const zod = __importStar(require("zod"));
+const ValidatorHelper_1 = require("./ValidatorHelper");
+// class
+class EnumValidator {
+    constructor(schema, field) {
+        this.schema = schema;
+        // initialize instance variables
+        this._zod = createZod(schema, field);
+    }
+    filter(errors, level) {
+        return ValidatorHelper_1.ValidatorHelper.filterErrors(errors, level);
+    }
+    validate(field, rawData) {
+        // skip if there's success
+        const data = rawData !== null && rawData !== void 0 ? rawData : {};
+        const { value } = data;
+        const { success, error } = this._zod.safeParse(value);
+        if (success) {
+            return [];
+        }
+        // otherwise, transform errors
+        else {
+            return error.issues.map(issue => ValidatorHelper_1.ValidatorHelper.createError({
+                field,
+                id: issue.message,
+                critical: issue.message !== 'required',
+                value
+            }));
+        }
+    }
+}
+exports.EnumValidator = EnumValidator;
+function createZod(schema, field) {
+    // create initial zod instance
+    const values = Object.keys(schema.options);
+    const validator = zod.ZodEnum.create(values, { required_error: 'required' });
+    // return final zod instance (handling optionality)
+    return field.required
+        ? validator
+        : validator.optional();
+}

package/dist/ui/fields/validators/GenericValidator.d.ts

@@ -0,0 +1,6 @@
+import type { Field as FieldModel } from '../Field';
+import type { FieldValidator } from '../FieldValidator';
+export declare class GenericValidator {
+    filter(errors: ReadonlyArray<FieldValidator.Error>, level: FieldValidator.Error.Level): ReadonlyArray<FieldValidator.Error>;
+    validate(field: FieldModel, rawData: any): FieldValidator.Error[];
+}

package/dist/ui/fields/validators/GenericValidator.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericValidator = void 0;
+const ValidatorHelper_1 = require("./ValidatorHelper");
+// class
+class GenericValidator {
+    filter(errors, level) {
+        return ValidatorHelper_1.ValidatorHelper.filterErrors(errors, level);
+    }
+    validate(field, rawData) {
+        // handle case where unset (fail if not optional)
+        const data = rawData;
+        if (!data || data.value === undefined) {
+            return field.required
+                ? [ValidatorHelper_1.ValidatorHelper.createError({ field, id: 'required', value: data })]
+                : [];
+        }
+        // otherwise, assume all is good
+        return [];
+    }
+}
+exports.GenericValidator = GenericValidator;

package/dist/ui/fields/validators/LinkValidator.d.ts

@@ -0,0 +1,9 @@
+import type { LinkField } from '../../../schema/field/base/LinkField';
+import type { Field as FieldModel } from '../Field';
+import type { FieldValidator } from '../FieldValidator';
+export declare class LinkValidator {
+    readonly schema: LinkField;
+    constructor(schema: LinkField);
+    filter(errors: ReadonlyArray<FieldValidator.Error>, level: FieldValidator.Error.Level): ReadonlyArray<FieldValidator.Error>;
+    validate(field: FieldModel, rawData: any): FieldValidator.Error[];
+}

package/dist/ui/fields/validators/LinkValidator.js

@@ -0,0 +1,146 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkValidator = void 0;
+const zod = __importStar(require("zod"));
+const errors_1 = require("../../../errors");
+const UrlUtils_1 = require("../../../utils/UrlUtils");
+const Value_1 = require("../../../utils/Value");
+const ValidatorHelper_1 = require("./ValidatorHelper");
+// class
+class LinkValidator {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    filter(errors, level) {
+        return ValidatorHelper_1.ValidatorHelper.filterErrors(errors, level);
+    }
+    validate(field, rawData) {
+        var _a, _b;
+        // handle case where unset (fail if not optional)
+        const data = rawData;
+        if (!data || !data.value) {
+            return field.required
+                ? [ValidatorHelper_1.ValidatorHelper.createError({ field, id: 'required', value: data })]
+                : [];
+        }
+        // internal link
+        const { value } = data;
+        switch (value.type) {
+            case 'internal': {
+                // validate both page type and slug is filled out
+                const { id, type } = (_b = (_a = value === null || value === void 0 ? void 0 : value.page) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : {};
+                if (!id || !type) {
+                    return [ValidatorHelper_1.ValidatorHelper.createError({ field, id: 'required', value })];
+                }
+                // otherwise valid
+                else {
+                    return [];
+                }
+            }
+            case 'external': {
+                // skip if it's relative
+                const { url } = value;
+                if (url && UrlUtils_1.UrlUtils.isRelativeUrl(url)) {
+                    return [];
+                }
+                // success if it parsed
+                const { success, error } = zodUrl.safeParse(url);
+                if (success) {
+                    return [];
+                }
+                // otherwise, transform errors
+                else {
+                    return error.issues.map(issue => ValidatorHelper_1.ValidatorHelper.createError({
+                        field,
+                        id: issue.message,
+                        critical: issue.message !== 'required',
+                        visual: false,
+                        value: url
+                    }));
+                }
+            }
+            case 'email': {
+                // success if it parsed
+                const { email } = value;
+                const { success, error } = zodEmail.safeParse(email);
+                if (success) {
+                    return [];
+                }
+                // otherwise, transform errors
+                else {
+                    return error.issues.map(issue => ValidatorHelper_1.ValidatorHelper.createError({
+                        field,
+                        id: issue.message,
+                        critical: issue.message !== 'required',
+                        visual: false,
+                        value: email
+                    }));
+                }
+            }
+            case 'phone': {
+                // success if it parsed
+                const { number } = value;
+                const { success, error } = zodPhone.safeParse(number);
+                if (success) {
+                    return [];
+                }
+                // otherwise, transform errors
+                else {
+                    return error.issues.map(issue => ValidatorHelper_1.ValidatorHelper.createError({
+                        field,
+                        id: issue.message,
+                        critical: issue.message !== 'required',
+                        visual: false,
+                        value: number
+                    }));
+                }
+            }
+            case 'file': {
+                // TODO: handle file reference validation
+                return [];
+            }
+            default:
+                console.error('Invalid link', value);
+                throw new errors_1.IllegalStateError('Link value is not valid');
+        }
+    }
+}
+exports.LinkValidator = LinkValidator;
+// helpers
+const zodUrl = zod.ZodString.create({ required_error: 'required' }).url('url');
+const zodEmail = zod.ZodString.create({ required_error: 'required' }).email('email');
+const zodPhone = zod.ZodString.create({ required_error: 'required' })
+    .refine(value => Value_1.Value.isPhoneNumber(value), 'phone');

package/dist/ui/fields/validators/RichTextValidator.d.ts

@@ -0,0 +1,6 @@
+import type { Field as FieldModel } from '../Field';
+import type { FieldValidator } from '../FieldValidator';
+export declare class RichTextValidator {
+    filter(errors: ReadonlyArray<FieldValidator.Error>, level: FieldValidator.Error.Level): ReadonlyArray<FieldValidator.Error>;
+    validate(field: FieldModel, rawData: any): FieldValidator.Error[];
+}

package/dist/ui/fields/validators/RichTextValidator.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RichTextValidator = void 0;
+const richtext_1 = require("../../richtext");
+const ValidatorHelper_1 = require("./ValidatorHelper");
+// class
+class RichTextValidator {
+    filter(errors, level) {
+        return ValidatorHelper_1.ValidatorHelper.filterErrors(errors, level);
+    }
+    validate(field, rawData) {
+        var _a, _b;
+        // handle case where unset (fail if not optional)
+        const data = rawData;
+        const text = richtext_1.LexicalUtils.rootToString((_b = (_a = data === null || data === void 0 ? void 0 : data.value) === null || _a === void 0 ? void 0 : _a.editorState) === null || _b === void 0 ? void 0 : _b.root);
+        // handle required
+        const length = text.trim().length;
+        if (length === 0) {
+            return field.required
+                ? [ValidatorHelper_1.ValidatorHelper.createError({ field, id: 'required', value: data })]
+                : [];
+        }
+        // handle min/max length
+        const { schema: { minLength, maxLength } } = field;
+        if (minLength && length < minLength) {
+            return [ValidatorHelper_1.ValidatorHelper.createError({ field, id: 'minLength', value: data })];
+        }
+        else if (maxLength && length > maxLength) {
+            return [ValidatorHelper_1.ValidatorHelper.createError({ field, id: 'maxLength', value: data })];
+        }
+        // otherwise, assume all is good
+        return [];
+    }
+}
+exports.RichTextValidator = RichTextValidator;

package/dist/ui/fields/validators/TextValidator.d.ts

@@ -0,0 +1,10 @@
+import type { TextField } from '../../../schema/field/base/TextField';
+import type { Field as FieldModel } from '../Field';
+import type { FieldValidator } from '../FieldValidator';
+export declare class TextValidator {
+    readonly schema: TextField;
+    private readonly _zod;
+    constructor(schema: TextField, field: FieldModel);
+    filter(errors: ReadonlyArray<FieldValidator.Error>, level: FieldValidator.Error.Level): ReadonlyArray<FieldValidator.Error>;
+    validate(field: FieldModel, rawData: any): FieldValidator.Error[];
+}

package/dist/ui/fields/validators/TextValidator.js

@@ -0,0 +1,138 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextValidator = void 0;
+const zod = __importStar(require("zod"));
+const UrlUtils_1 = require("../../../utils/UrlUtils");
+const ValidatorHelper_1 = require("./ValidatorHelper");
+// class
+class TextValidator {
+    constructor(schema, field) {
+        this.schema = schema;
+        // initialize instance variables
+        this._zod = createZod(schema, field);
+    }
+    filter(errors, level) {
+        return ValidatorHelper_1.ValidatorHelper.filterErrors(errors, level);
+    }
+    validate(field, rawData) {
+        var _a, _b;
+        // skip if there's success
+        const data = rawData;
+        const value = ((_a = data === null || data === void 0 ? void 0 : data.value) !== null && _a !== void 0 ? _a : '').trim();
+        const { _zod, schema } = this;
+        const { exact } = schema;
+        const exactError = !!exact && exact !== value;
+        const { success, error } = _zod.safeParse(value);
+        if (success && !exactError) {
+            return [];
+        }
+        // or skip if it's empty and not required
+        else if (value.length === 0 && this._zod.isOptional()) {
+            return [];
+        }
+        // return exact error if that's there
+        else if (exactError) {
+            return [
+                ValidatorHelper_1.ValidatorHelper.createError({
+                    field,
+                    id: 'exact',
+                    critical: true,
+                    visual: true,
+                    value
+                })
+            ];
+        }
+        // otherwise, transform errors
+        else {
+            // use zod errors
+            const issues = (_b = error === null || error === void 0 ? void 0 : error.issues.map(issue => ValidatorHelper_1.ValidatorHelper.createError({
+                field,
+                id: issue.message,
+                critical: !nonCriticalIssues.has(issue.message),
+                visual: visualIssues.has(issue.message),
+                value
+            }))) !== null && _b !== void 0 ? _b : [];
+            // return only required if it's an issue
+            const [emptyIssue] = issues.filter(issue => issue.id === 'required' || issue.id === 'empty');
+            return emptyIssue
+                ? [emptyIssue]
+                : issues;
+        }
+    }
+}
+exports.TextValidator = TextValidator;
+const nonCriticalIssues = new Set(['required', 'empty']);
+const visualIssues = new Set(['regex']);
+function createZod(schema, field) {
+    // create initial zod instance
+    let validator = zod.ZodString.create({ required_error: 'required' });
+    // add semantic validation
+    switch (schema.semantics) {
+        case 'email':
+            validator = validator.email('email');
+            break;
+        case 'phone':
+            // Looks to make sure we have between 7-15 digits, and allows for the following characters: (,),-, +, space
+            validator = validator.regex(/^(?=(?:\D*\d){7,15}\D*$)[\d\s+\-\\]+$/, 'phone');
+            break;
+        case 'url':
+            validator = validator.regex(/^((https?:\/\/)?([\w-]+\.)+[\w-]+(\/[\w\-._~:/?#[\]@!$&'()*+,;=%]*)?)|(\/[\w\-._~:/?#[\]@!$&'()*+,;=%]*)$/, 'url');
+            break;
+    }
+    // regex
+    if (schema.regex) {
+        validator = validator.regex(schema.regex, schema.semantics === 'password' ? 'regex.password' : 'regex');
+    }
+    // min-length
+    if (schema.minLength !== undefined) {
+        validator = validator.min(schema.minLength, { message: 'minLength' });
+    }
+    // max-length
+    if (schema.maxLength !== undefined) {
+        validator = validator.max(schema.maxLength, { message: 'maxLength' });
+    }
+    // handle custom uri (
+    if (schema.semantics === 'uri') {
+        const invalidFallback = '__invalid__';
+        validator = validator.refine(value => UrlUtils_1.UrlUtils.coerce(value, invalidFallback) !== invalidFallback, { message: 'uri' });
+    }
+    // return final zod instance (handling optionality)
+    return field.required
+        ? validator instanceof zod.ZodEffects
+            ? validator
+            : validator.nonempty('empty')
+        : validator.optional();
+}

package/dist/ui/fields/validators/TimestampValidator.d.ts

@@ -0,0 +1,9 @@
+import type { TimestampField } from '../../../schema/field/base/TimestampField';
+import type { Field as FieldModel } from '../Field';
+import type { FieldValidator } from '../FieldValidator';
+export declare class TimestampValidator {
+    readonly schema: TimestampField;
+    constructor(schema: TimestampField);
+    filter(errors: ReadonlyArray<FieldValidator.Error>, level: FieldValidator.Error.Level): ReadonlyArray<FieldValidator.Error>;
+    validate(field: FieldModel, rawData: any): FieldValidator.Error[];
+}

package/dist/ui/fields/validators/TimestampValidator.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimestampValidator = void 0;
+const Timestamp_1 = require("../../../types/Timestamp");
+const ValidatorHelper_1 = require("./ValidatorHelper");
+// class
+class TimestampValidator {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    filter(errors, level) {
+        return ValidatorHelper_1.ValidatorHelper.filterErrors(errors, level);
+    }
+    validate(field, rawData) {
+        // handle case where unset (fail if not optional)
+        const data = rawData;
+        if (!data || !data.value) {
+            return field.required
+                ? [ValidatorHelper_1.ValidatorHelper.createError({ field, id: 'required', value: data })]
+                : [];
+        }
+        // fail if invalid format
+        const { value } = data;
+        if (!Timestamp_1.Timestamp.filter(value)) {
+            return [ValidatorHelper_1.ValidatorHelper.createError({ field, id: 'timestamp', critical: true, value })];
+        }
+        // or fail if minDate is violated
+        const { minTime, maxTime } = this.schema;
+        if (minTime && Timestamp_1.Timestamp.isBefore(value, minTime)) {
+            return [ValidatorHelper_1.ValidatorHelper.createError({ field, id: 'timestamp.minTime', critical: true, value })];
+        }
+        else if (maxTime && Timestamp_1.Timestamp.isBefore(value, maxTime)) {
+            return [ValidatorHelper_1.ValidatorHelper.createError({ field, id: 'timestamp.maxTime', critical: true, value })];
+        }
+        // otherwise, transform errors
+        else {
+            return [];
+        }
+    }
+}
+exports.TimestampValidator = TimestampValidator;

package/dist/ui/fields/validators/ValidatorHelper.d.ts

@@ -0,0 +1,23 @@
+import { Language } from '../../../regionalization';
+import type { Field } from '../Field';
+import type { FieldList } from '../FieldList';
+import type { FieldValidator } from '../FieldValidator';
+export declare namespace ValidatorHelper {
+    function filterErrors(errors: ReadonlyArray<FieldValidator.Error>, level: FieldValidator.Error.Level): ReadonlyArray<FieldValidator.Error>;
+    type CreateErrorArgs = {
+        field: Field | FieldList;
+        id: string;
+        critical?: boolean;
+        visual?: boolean;
+        value: any;
+        language?: Language;
+    };
+    function createError({ field, id, critical, visual, value, language }: CreateErrorArgs): FieldValidator.Error;
+    type GetErrorMessageArgs = {
+        field: Field | FieldList;
+        id: string;
+        value: any;
+        language?: Language;
+    };
+    function getErrorMessage({ field, id, value, language }: GetErrorMessageArgs): any;
+}

package/dist/ui/fields/validators/ValidatorHelper.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidatorHelper = void 0;
+const Optional_1 = require("../../../schema/Optional");
+const errors_json_1 = __importDefault(require("../errors.json"));
+// namespace
+var ValidatorHelper;
+(function (ValidatorHelper) {
+    // methods
+    function filterErrors(errors, level) {
+        switch (level) {
+            case 'none':
+                return [];
+            case 'critical':
+                return errors.filter(({ critical, visual }) => critical && !visual);
+            default:
+                return errors;
+        }
+    }
+    ValidatorHelper.filterErrors = filterErrors;
+    function createError({ field, id, critical = false, visual = false, value, language }) {
+        return {
+            id: id,
+            critical,
+            visual,
+            message: getErrorMessage({ field, id, value, language })
+        };
+    }
+    ValidatorHelper.createError = createError;
+    function getErrorMessage({ field, id, value, language = 'en' }) {
+        var _a;
+        // try to fetch the localized error message (or return an error indicator)
+        const messages = (_a = errors_json_1.default[language]) !== null && _a !== void 0 ? _a : errors_json_1.default['en'];
+        const errorCopy = messages && messages[id];
+        if (!errorCopy) {
+            return id;
+        }
+        // replace and return variables (if any... using constraints)
+        const { schema } = Optional_1.Optional.unwrap(field.schema);
+        const constraints = schema;
+        return errorCopy.replace(/(\${(\w+)})/gm, (_match, _variableWrap, variableRaw) => {
+            // try to grab variable from copy
+            const variable = variableRaw;
+            const errorMessage = variable === 'label'
+                ? field.name
+                : String(constraints[variable]);
+            // return message (or variable)
+            return errorMessage || `missing <${variable}>`;
+        });
+    }
+    ValidatorHelper.getErrorMessage = getErrorMessage;
+})(ValidatorHelper || (exports.ValidatorHelper = ValidatorHelper = {}));

package/dist/ui/fields/validators/index.d.ts

@@ -0,0 +1,8 @@
+export * from './AssetValidator';
+export * from './DateValidator';
+export * from './EnumValidator';
+export * from './GenericValidator';
+export * from './LinkValidator';
+export * from './RichTextValidator';
+export * from './TextValidator';
+export * from './TimestampValidator';

package/dist/ui/fields/validators/index.js

@@ -0,0 +1,24 @@
+"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("./AssetValidator"), exports);
+__exportStar(require("./DateValidator"), exports);
+__exportStar(require("./EnumValidator"), exports);
+__exportStar(require("./GenericValidator"), exports);
+__exportStar(require("./LinkValidator"), exports);
+__exportStar(require("./RichTextValidator"), exports);
+__exportStar(require("./TextValidator"), exports);
+__exportStar(require("./TimestampValidator"), exports);

package/dist/ui/geometry/AspectRatio.d.ts

@@ -0,0 +1,27 @@
+export declare class AspectRatio {
+    readonly width: number;
+    readonly height: number;
+    constructor(value: AspectRatio.Value);
+    get ratio(): number;
+    isSimilarTo(that: AspectRatio): boolean;
+    toString(): AspectRatio.String;
+}
+export declare namespace AspectRatio {
+    type Value = Data | String | Tuple;
+    type Data = {
+        width: number;
+        height: number;
+    };
+    namespace Data {
+        function parse(value: string | Tuple | Data): Data;
+    }
+    type String = `${number}:${number}`;
+    namespace String {
+        function filter(value: string): value is String;
+        function parse(value: String): Data;
+    }
+    type Tuple = [number, number];
+    namespace Tuple {
+        function parse([width, height]: Tuple): Data;
+    }
+}