lucid-extension-sdk 0.0.31 → 0.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "lucid-extension-sdk",
-    "version": "0.0.31",
+    "version": "0.0.32",
     "description": "Utility classes for writing Lucid Software editor extensions",
     "main": "sdk/index.js",
     "types": "sdk/index.d.ts",

package/sdk/core/guards.d.ts

@@ -0,0 +1,8 @@
+import { WithUndefinedAsOptional } from './optionalkey';
+export declare type GuardToType<Guard> = Guard extends (p1: unknown) => p1 is infer Type ? Type : never;
+export declare type DestructureGuardedTypeObj<Obj extends {
+    [key: string]: (p1: unknown) => p1 is unknown;
+}> = WithUndefinedAsOptional<{
+    [key in keyof Obj]: GuardToType<Obj[key]>;
+}>;
+export declare type Validator<TO extends FROM, FROM = unknown> = (p1: FROM) => p1 is TO;

package/sdk/core/guards.js

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

package/sdk/core/object.d.ts

@@ -0,0 +1,3 @@
+export declare function objectEvery<T, O extends {
+    [key: string]: any;
+}>(obj: O, f: (this: T | undefined, _0: O[typeof _1], _1: string & keyof O, _2: O) => any, opt_this?: T): boolean;

package/sdk/core/object.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectEvery = void 0;
+function objectEvery(obj, f, opt_this) {
+    for (const key in obj) {
+        if (!f.call(opt_this, obj[key], key, obj)) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.objectEvery = objectEvery;

package/sdk/core/optionalkey.d.ts

@@ -0,0 +1,20 @@
+declare type DefinedKeys<T> = Exclude<{
+    [P in keyof T]: undefined extends T[P] ? never : P;
+}[keyof T], undefined>;
+declare type UndefinedKeys<T> = Exclude<{
+    [P in keyof T]: undefined extends T[P] ? P : never;
+}[keyof T], undefined>;
+/**
+ * WithUndefinedAsOptional<{a: number|undefined, b: number, c: any}> => {a?: number|undefined, b:number, c?: any}
+ */
+export declare type WithUndefinedAsOptional<T extends object> = {
+    [key in keyof T]+?: T[key];
+} & {
+    [key in DefinedKeys<T>]-?: T[key];
+};
+export declare type WithUndefinedAsOptionalRecursive<T> = T extends object ? {
+    [key in DefinedKeys<T>]-?: WithUndefinedAsOptionalRecursive<T[key]>;
+} & {
+    [key in UndefinedKeys<T>]+?: WithUndefinedAsOptionalRecursive<T[key]>;
+} : T;
+export {};

package/sdk/core/optionalkey.js

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

package/sdk/core/validators/validators.d.ts

@@ -0,0 +1,220 @@
+import { isNumber, isString } from '../checks';
+import { DestructureGuardedTypeObj, GuardToType, Validator } from '../guards';
+/*********************************************************************************
+ * Validator generators:  These functions construct new composite validators
+ *from elemental validators.
+ ********************************************************************************/
+/**
+ * Creates a validator which tests if the target is a string
+ * and is one of the values in the specified enum (object).
+ */
+export declare function stringEnumValidator<T>(enumMap: T): (x: unknown) => x is T[keyof T];
+/**
+ * Creates a validator which tests if the target is a value in the specified enum.
+ * Note that numbers in enums are reverse-mapped by the TS transpiler, so the specified keys are also values.
+ */
+export declare function enumValidator<T>(enumMap: T): (x: unknown) => x is T[keyof T];
+/**
+ * Creates a validator which tests if the target is a number
+ * and is equal to or between the min and max values.
+ *
+ */
+export declare function rangeValidator(min: number, max: number): (x: unknown) => x is number;
+/**
+ * Creates a validator which tests if the target is an array
+ * and if all elements of the array satisfy the given
+ * sub-validator.
+ *
+ * @return A validator for the array type
+ */
+export declare function arrayValidator<T>(subValidator: (p1: unknown) => p1 is T): (p1: unknown) => p1 is T[];
+/**
+ * Creates a validator for a fixed width array where each entry
+ * in the array can have a separate validator
+ */
+export declare function tupleValidator<V extends ((p1: unknown) => p1 is unknown)[]>(...tupleValidators: V): (x: any) => x is { [key in keyof V]: GuardToType<V[key]>; };
+/**
+ * Creates a validator that the given unknown is one of the supplied values
+ */
+export declare function someValue<T extends any[]>(...values: T): (x: unknown) => x is T[number];
+/**
+ * Creates a validator that the given unknown matches at least one of the given validators
+ */
+export declare function someValidator<T, A extends ((p1: unknown) => p1 is T)[]>(...validators: A): (x: any) => x is GuardToType<A[number]>;
+/**
+ * Creates a validator which tests if the target is an object
+ * and if all values in the object satisfy the given sub-validator.
+ * This does *not* perform any tests on the object keys, which
+ * are allowed to be arbitrary strings.
+ *
+ * @return A validator for the map
+ * Note that unlike objectValidator, this performs no validation on the names or
+ * number of the keys and treats all values equally
+ */
+export declare function mapValidator<T>(subValidator: (p1: unknown) => p1 is T): (x: unknown) => x is {
+    [key: string]: T;
+};
+/**
+ * Creates a validator which tests if the target is an object
+ * and if the structure of the object matches the structure of the passed-in
+ * validator object.  The values in the validator object are in turn
+ * validators.  This means that if the validator object has a (key,value)
+ * pair of the form ('key', keyValidator), then in order for the target object
+ * (x) to match, keyValidator(x['key']) must return true for all keys in the
+ * validatorStructure.
+ *
+ * Note that you can use `lucid.validators.option` to create optional parameters
+ * in validation structure.
+ */
+export declare function objectValidator<T extends {
+    [key: string]: (p1: unknown) => p1 is unknown;
+}>(validatorStructure: T): (subject: unknown) => subject is DestructureGuardedTypeObj<T>;
+/**
+ * Similar to {@link objectValidator}, but if the object has any non-undefined keys, they must also be present in the validator structure.
+ * This is useful for things where extra data is unwanted, like Property serialization.
+ * the loose version is often prefered because this one makes backwards compatible changes to the data harder,
+ * because it requires an additional PR when the data transfers between services:
+ * 1. A PR that adds the option() to this validator; 2. A PR that sends the new data; 3. A PR to remove the option();
+ * compared to the (non-strict)objectValidator steps:
+ * 1. A PR that adds the option() to this validator and sends the new data; 2. A PR to remove the option();
+ */
+export declare function strictObjectValidator<T extends {
+    [key: string]: (p1: unknown) => p1 is unknown;
+}>(validatorStructure: T): (subject: unknown) => subject is DestructureGuardedTypeObj<T>;
+export declare function recordValidator<K extends string, V>(keyList: K[], valueValidator: Validator<V>): (x: unknown) => x is Record<K, V>;
+export declare function objectOfValidator<T>(subValidator: Validator<T>): (x: unknown) => x is Record<any, T>;
+/**
+ * Create a validator which allows the target to be either null or satisfy the
+ * sub-validator.
+ *
+ * @return A validator for the array type
+ */
+export declare function nullable<T>(subValidator: (p1: unknown) => p1 is T): (x: unknown) => x is T | null;
+/**
+ * Create a validator which allows the target to be undefined or satisfy the
+ * sub-validator.
+ *
+ * @return A validator for the array type
+ */
+export declare function option<T>(subValidator: (p1: unknown) => p1 is T): (x: unknown) => x is T | undefined;
+/**
+ * Create a validator which allows the target to be undefined, null, or satisfy
+ * the sub-validator.
+ *
+ * @return A validator for the array type
+ */
+export declare function nullableOption<T>(subValidator: (p1: unknown) => p1 is T): (x: unknown) => x is T | null | undefined;
+export declare const isNullOption: (value: unknown) => value is null | undefined;
+/**
+ * Create a validator that merges two validators.
+ * This is useful for validating properties that have 2 disjoint sets of possible values.
+ * e.g. {someObject: string}|false
+ */
+export declare function either<A, B>(validatorA: Validator<A>, validatorB: Validator<B>): (x: unknown) => x is A | B;
+/**
+ * Create a validator that combines two validators.
+ * This is useful for validating properties that have been composed of a generic and more specific values.
+ */
+export declare function both<A, B>(validatorA: Validator<A>, validatorB: Validator<B>): (x: unknown) => x is A & B;
+/**
+ * Get a validator which returns whether the property calculation structure is
+ * correct.
+ */
+export declare function propertyValidator<T>(subValidator: (p1: unknown) => p1 is T, preSaveActions: ((p1: unknown) => unknown)[]): (subject: unknown) => subject is DestructureGuardedTypeObj<{
+    Equation: typeof isString;
+    StaticValue: (x: unknown) => x is unknown;
+}>;
+/*********************************************************************************
+ * Validators:  Some useful predefined validator functions.
+ ********************************************************************************/
+/**
+ * This validator only allows objects whose values are all booleans set to true.
+ *
+ * @return A validator for the map
+ */
+export declare function isSet(x: unknown): x is {
+    [key: string]: true;
+};
+/**
+ * This validator validates that value is either number or empty string
+ */
+export declare const isNumberOrEmptyString: (x: unknown) => x is number | "";
+/**
+ * This validator validates that value is either boolean or empty string
+ */
+export declare const isBooleanOrEmptyString: (x: unknown) => x is boolean | "";
+/**
+ * This validator validates that value is either string or -1
+ */
+export declare const isStringOrNegativeOne: (x: unknown) => x is string | -1;
+/**
+ * This validator validates model of lucid.model.restrictions
+ */
+export declare const isRestrictions: (subject: unknown) => subject is DestructureGuardedTypeObj<{
+    b: (x: unknown) => x is boolean | null | undefined;
+    p: (x: unknown) => x is boolean | null | undefined;
+    c: (x: unknown) => x is boolean | null | undefined;
+    f: (x: unknown) => x is boolean | null | undefined;
+    o: (x: unknown) => x is boolean | null | undefined;
+    e: (x: unknown) => x is boolean | null | undefined;
+    fc: (x: unknown) => x is boolean | null | undefined;
+    fs: (x: unknown) => x is boolean | null | undefined;
+    l: (x: unknown) => x is boolean | null | undefined;
+    i: (x: unknown) => x is boolean | null | undefined;
+    u: (x: unknown) => x is boolean | null | undefined;
+    acap: (x: unknown) => x is boolean | null | undefined;
+    scap: (x: unknown) => x is boolean | null | undefined;
+    imageCategory: (x: unknown) => x is boolean | null | undefined;
+    pcad: (x: unknown) => x is boolean | null | undefined;
+}>;
+/**
+ * Returns true if the target is equal to either zero or one or is a boolean.
+ *
+ */
+export declare function isFlag(x: unknown): x is 0 | 1 | boolean;
+export declare function isTrue(x: unknown): x is true;
+/**
+ * Returns if an object is a number between 0 and 100.
+ *
+ */
+export declare const isOpacity: (x: unknown) => x is number;
+/**
+ * Tests if the given target satisfies the PointLike interface.
+ *
+ */
+export declare const isPointLike: (subject: unknown) => subject is DestructureGuardedTypeObj<{
+    x: typeof isNumber;
+    y: typeof isNumber;
+}>;
+/**
+ * Tests if the given target is a bounding box.
+ *
+ */
+export declare const isBoundingBox: (subject: unknown) => subject is DestructureGuardedTypeObj<{
+    x: typeof isNumber;
+    y: typeof isNumber;
+    w: typeof isNumber;
+    h: typeof isNumber;
+}>;
+/**
+ * Tests if the given target is a panel size.
+ *
+ */
+export declare const isPanelSize: (subject: unknown) => subject is DestructureGuardedTypeObj<{
+    x: typeof isNumber;
+    y: typeof isNumber;
+    w: typeof isNumber;
+    h: typeof isNumber;
+    identifier: (x: unknown) => x is string | null | undefined;
+}>;
+export declare const isSize: (subject: unknown) => subject is DestructureGuardedTypeObj<{
+    w: typeof isNumber;
+    h: typeof isNumber;
+}>;
+export declare function isPositiveNumber(x: unknown): x is number;
+export declare function isDate(x: unknown): x is Date;
+export declare function maxLengthValidator(max: number): (x: unknown) => x is string;
+export declare function minLengthValidator(min: number): (x: unknown) => x is string;
+export declare type ValidatorWithMessage = (x: unknown) => true | string;
+export declare function validatorWithMessage<T>(validator: (x: unknown) => x is T, message: string, sub?: ValidatorWithMessage): ValidatorWithMessage;
+export declare function asAssertion<TO extends FROM, FROM>(validator: Validator<TO, FROM>): (val: FROM) => asserts val is TO;

package/sdk/core/validators/validators.js

@@ -0,0 +1,376 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asAssertion = exports.validatorWithMessage = exports.minLengthValidator = exports.maxLengthValidator = exports.isDate = exports.isPositiveNumber = exports.isSize = exports.isPanelSize = exports.isBoundingBox = exports.isPointLike = exports.isOpacity = exports.isTrue = exports.isFlag = exports.isRestrictions = exports.isStringOrNegativeOne = exports.isBooleanOrEmptyString = exports.isNumberOrEmptyString = exports.isSet = exports.propertyValidator = exports.both = exports.either = exports.isNullOption = exports.nullableOption = exports.option = exports.nullable = exports.objectOfValidator = exports.recordValidator = exports.strictObjectValidator = exports.objectValidator = exports.mapValidator = exports.someValidator = exports.someValue = exports.tupleValidator = exports.arrayValidator = exports.rangeValidator = exports.enumValidator = exports.stringEnumValidator = void 0;
+const checks_1 = require("../checks");
+const object_1 = require("../object");
+/*********************************************************************************
+ * Validator generators:  These functions construct new composite validators
+ *from elemental validators.
+ ********************************************************************************/
+/**
+ * Creates a validator which tests if the target is a string
+ * and is one of the values in the specified enum (object).
+ */
+function stringEnumValidator(enumMap) {
+    return (x) => {
+        if (!(0, checks_1.isString)(x)) {
+            return false;
+        }
+        for (const key in enumMap) {
+            if (enumMap[key] === x) {
+                return true;
+            }
+        }
+        return false;
+    };
+}
+exports.stringEnumValidator = stringEnumValidator;
+/**
+ * Creates a validator which tests if the target is a value in the specified enum.
+ * Note that numbers in enums are reverse-mapped by the TS transpiler, so the specified keys are also values.
+ */
+function enumValidator(enumMap) {
+    return (x) => {
+        for (const key in enumMap) {
+            if (enumMap[key] === x) {
+                return true;
+            }
+        }
+        return false;
+    };
+}
+exports.enumValidator = enumValidator;
+/**
+ * Creates a validator which tests if the target is a number
+ * and is equal to or between the min and max values.
+ *
+ */
+function rangeValidator(min, max) {
+    return (x) => {
+        return (0, checks_1.isNumber)(x) && x >= min && x <= max;
+    };
+}
+exports.rangeValidator = rangeValidator;
+/**
+ * Creates a validator which tests if the target is an array
+ * and if all elements of the array satisfy the given
+ * sub-validator.
+ *
+ * @return A validator for the array type
+ */
+function arrayValidator(subValidator) {
+    return (x) => {
+        return (0, checks_1.isArray)(x) && x.every(subValidator);
+    };
+}
+exports.arrayValidator = arrayValidator;
+/**
+ * Creates a validator for a fixed width array where each entry
+ * in the array can have a separate validator
+ */
+function tupleValidator(...tupleValidators) {
+    return (x) => {
+        return (typeof x === 'object' &&
+            tupleValidators.length === x.length &&
+            tupleValidators.every((subX, index) => subX(x[index])));
+    };
+}
+exports.tupleValidator = tupleValidator;
+/**
+ * Creates a validator that the given unknown is one of the supplied values
+ */
+function someValue(...values) {
+    return (x) => {
+        for (const value of values) {
+            if (x === value) {
+                return true;
+            }
+        }
+        return false;
+    };
+}
+exports.someValue = someValue;
+/**
+ * Creates a validator that the given unknown matches at least one of the given validators
+ */
+function someValidator(...validators) {
+    return (x) => {
+        for (const validator of validators) {
+            if (validator(x)) {
+                return true;
+            }
+        }
+        return false;
+    };
+}
+exports.someValidator = someValidator;
+/**
+ * Creates a validator which tests if the target is an object
+ * and if all values in the object satisfy the given sub-validator.
+ * This does *not* perform any tests on the object keys, which
+ * are allowed to be arbitrary strings.
+ *
+ * @return A validator for the map
+ * Note that unlike objectValidator, this performs no validation on the names or
+ * number of the keys and treats all values equally
+ */
+function mapValidator(subValidator) {
+    return (x) => {
+        return (0, checks_1.isObject)(x) && !(0, checks_1.isArray)(x) && (0, object_1.objectEvery)(x, subValidator);
+    };
+}
+exports.mapValidator = mapValidator;
+/**
+ * Creates a validator which tests if the target is an object
+ * and if the structure of the object matches the structure of the passed-in
+ * validator object.  The values in the validator object are in turn
+ * validators.  This means that if the validator object has a (key,value)
+ * pair of the form ('key', keyValidator), then in order for the target object
+ * (x) to match, keyValidator(x['key']) must return true for all keys in the
+ * validatorStructure.
+ *
+ * Note that you can use `lucid.validators.option` to create optional parameters
+ * in validation structure.
+ */
+function objectValidator(validatorStructure) {
+    return (subject) => {
+        if ((0, checks_1.isArray)(subject) || !(0, checks_1.isObject)(subject)) {
+            return false;
+        }
+        else {
+            return (0, object_1.objectEvery)(validatorStructure, (validator, key) => {
+                return validator(subject[key]);
+            });
+        }
+    };
+}
+exports.objectValidator = objectValidator;
+/**
+ * Similar to {@link objectValidator}, but if the object has any non-undefined keys, they must also be present in the validator structure.
+ * This is useful for things where extra data is unwanted, like Property serialization.
+ * the loose version is often prefered because this one makes backwards compatible changes to the data harder,
+ * because it requires an additional PR when the data transfers between services:
+ * 1. A PR that adds the option() to this validator; 2. A PR that sends the new data; 3. A PR to remove the option();
+ * compared to the (non-strict)objectValidator steps:
+ * 1. A PR that adds the option() to this validator and sends the new data; 2. A PR to remove the option();
+ */
+function strictObjectValidator(validatorStructure) {
+    const looseValidator = objectValidator(validatorStructure);
+    return (subject) => {
+        return (looseValidator(subject) &&
+            (0, object_1.objectEvery)(subject, (subx, key) => subx === undefined || validatorStructure.hasOwnProperty(key)));
+    };
+}
+exports.strictObjectValidator = strictObjectValidator;
+function recordValidator(keyList, valueValidator) {
+    return (x) => {
+        return ((0, checks_1.isObject)(x) &&
+            !(0, checks_1.isArray)(x) &&
+            keyList.every((k) => k in x) &&
+            (0, object_1.objectEvery)(x, (val, key) => {
+                return valueValidator(val);
+            }));
+    };
+}
+exports.recordValidator = recordValidator;
+function objectOfValidator(subValidator) {
+    return (x) => {
+        if ((0, checks_1.isArray)(x) || !(0, checks_1.isObject)(x)) {
+            return false;
+        }
+        return Object.values(x).every((val) => subValidator(val));
+    };
+}
+exports.objectOfValidator = objectOfValidator;
+/**
+ * Create a validator which allows the target to be either null or satisfy the
+ * sub-validator.
+ *
+ * @return A validator for the array type
+ */
+function nullable(subValidator) {
+    return (x) => {
+        return x === null || subValidator(x);
+    };
+}
+exports.nullable = nullable;
+/**
+ * Create a validator which allows the target to be undefined or satisfy the
+ * sub-validator.
+ *
+ * @return A validator for the array type
+ */
+function option(subValidator) {
+    return (x) => {
+        return x === undefined || subValidator(x);
+    };
+}
+exports.option = option;
+/**
+ * Create a validator which allows the target to be undefined, null, or satisfy
+ * the sub-validator.
+ *
+ * @return A validator for the array type
+ */
+function nullableOption(subValidator) {
+    return (x) => {
+        return x === null || x === undefined || subValidator(x);
+    };
+}
+exports.nullableOption = nullableOption;
+const isNullOption = (value) => {
+    return value == null;
+};
+exports.isNullOption = isNullOption;
+/**
+ * Create a validator that merges two validators.
+ * This is useful for validating properties that have 2 disjoint sets of possible values.
+ * e.g. {someObject: string}|false
+ */
+function either(validatorA, validatorB) {
+    return (x) => {
+        return validatorA(x) || validatorB(x);
+    };
+}
+exports.either = either;
+/**
+ * Create a validator that combines two validators.
+ * This is useful for validating properties that have been composed of a generic and more specific values.
+ */
+function both(validatorA, validatorB) {
+    return (x) => {
+        return validatorA(x) && validatorB(x);
+    };
+}
+exports.both = both;
+/**
+ * Get a validator which returns whether the property calculation structure is
+ * correct.
+ */
+function propertyValidator(subValidator, preSaveActions) {
+    const processedValidator = (x) => {
+        const y = preSaveActions.reduce((px, psa) => psa(px), x);
+        return subValidator(y);
+    };
+    return strictObjectValidator({ 'Equation': checks_1.isString, 'StaticValue': processedValidator });
+}
+exports.propertyValidator = propertyValidator;
+/*********************************************************************************
+ * Validators:  Some useful predefined validator functions.
+ ********************************************************************************/
+/**
+ * This validator only allows objects whose values are all booleans set to true.
+ *
+ * @return A validator for the map
+ */
+function isSet(x) {
+    return (0, checks_1.isObject)(x) && !(0, checks_1.isArray)(x) && (0, object_1.objectEvery)(x, (val) => (0, checks_1.isBoolean)(val) && !!val);
+}
+exports.isSet = isSet;
+/**
+ * This validator validates that value is either number or empty string
+ */
+exports.isNumberOrEmptyString = either(checks_1.isNumber, (v) => v === '');
+/**
+ * This validator validates that value is either boolean or empty string
+ */
+exports.isBooleanOrEmptyString = either(checks_1.isBoolean, (v) => v === '');
+/**
+ * This validator validates that value is either string or -1
+ */
+exports.isStringOrNegativeOne = either(checks_1.isString, (v) => v === -1);
+/**
+ * This validator validates model of lucid.model.restrictions
+ */
+exports.isRestrictions = strictObjectValidator({
+    'b': nullableOption(checks_1.isBoolean),
+    'p': nullableOption(checks_1.isBoolean),
+    'c': nullableOption(checks_1.isBoolean),
+    'f': nullableOption(checks_1.isBoolean),
+    'o': nullableOption(checks_1.isBoolean),
+    'e': nullableOption(checks_1.isBoolean),
+    'fc': nullableOption(checks_1.isBoolean),
+    'fs': nullableOption(checks_1.isBoolean),
+    'l': nullableOption(checks_1.isBoolean),
+    'i': nullableOption(checks_1.isBoolean),
+    'u': nullableOption(checks_1.isBoolean),
+    'acap': nullableOption(checks_1.isBoolean),
+    'scap': nullableOption(checks_1.isBoolean),
+    'imageCategory': nullableOption(checks_1.isBoolean),
+    'pcad': nullableOption(checks_1.isBoolean),
+});
+/**
+ * Returns true if the target is equal to either zero or one or is a boolean.
+ *
+ */
+function isFlag(x) {
+    return x === 0 || x === 1 || (0, checks_1.isBoolean)(x);
+}
+exports.isFlag = isFlag;
+function isTrue(x) {
+    return x === true;
+}
+exports.isTrue = isTrue;
+/**
+ * Returns if an object is a number between 0 and 100.
+ *
+ */
+exports.isOpacity = rangeValidator(0, 100);
+/**
+ * Tests if the given target satisfies the PointLike interface.
+ *
+ */
+exports.isPointLike = objectValidator({ x: checks_1.isNumber, y: checks_1.isNumber });
+/**
+ * Tests if the given target is a bounding box.
+ *
+ */
+exports.isBoundingBox = objectValidator({
+    x: checks_1.isNumber,
+    y: checks_1.isNumber,
+    w: checks_1.isNumber,
+    h: checks_1.isNumber,
+});
+/**
+ * Tests if the given target is a panel size.
+ *
+ */
+exports.isPanelSize = objectValidator({
+    x: checks_1.isNumber,
+    y: checks_1.isNumber,
+    w: checks_1.isNumber,
+    h: checks_1.isNumber,
+    'identifier': nullableOption(checks_1.isString),
+});
+exports.isSize = objectValidator({
+    w: checks_1.isNumber,
+    h: checks_1.isNumber,
+});
+function isPositiveNumber(x) {
+    return (0, checks_1.isNumber)(x) && x >= 0;
+}
+exports.isPositiveNumber = isPositiveNumber;
+function isDate(x) {
+    return x instanceof Date;
+}
+exports.isDate = isDate;
+function maxLengthValidator(max) {
+    return (x) => (0, checks_1.isString)(x) && x.length <= max;
+}
+exports.maxLengthValidator = maxLengthValidator;
+function minLengthValidator(min) {
+    return (x) => (0, checks_1.isString)(x) && x.length >= min;
+}
+exports.minLengthValidator = minLengthValidator;
+function validatorWithMessage(validator, message, sub) {
+    return (x) => (validator(x) ? (sub ? sub(x) : true) : message);
+}
+exports.validatorWithMessage = validatorWithMessage;
+function asAssertion(validator) {
+    return (val) => {
+        if (!validator(val)) {
+            throw new Error();
+        }
+    };
+}
+exports.asAssertion = asAssertion;