@woosh/meep-engine/src/core/assert.d.ts

Pure JavaScript game engine. Fully featured and production ready.

/**
 *
 * @param {boolean} t
 * @param {string} [m]
 */
export function assert(t: boolean, m?: string): void;
export namespace assert {
    /**
     * @template T
     * @param {T} value
     * @param {Object<T>} enumerable
     * @param {string} [name]
     */
    function _enum<T>(value: T, enumerable: any, name?: string): void;
    export { _enum as enum };
    export { notEqual };
    export { notOk };
    export { equal };
    export { logicalEquals as logicalyEqual };
    export { assert as ok };
    export { greaterThan };
    export { greaterThanOrEqual };
    export { lessThan };
    export { lessThanOrEqual };
    export { typeOf };
    export { arrayHas };
    export { arrayHasNo };
    export { arrayEqual };
    export { isOneOf };
    /**
     *
     * @param {*} value
     * @param {Class} klass
     * @param {string} [value_name]
     * @param {string} [class_name]
     */
    export function isInstanceOf(value: any, klass: Class, value_name?: string, class_name?: string): void;
    /**
     *
     * @param {number|*} value
     * @param {string} [name]
     */
    export function isNumber(value: any, name?: string): void;
    /**
     *
     * @param {string|*} value
     * @param {string} [name]
     */
    export function isString(value: any, name?: string): void;
    /**
     *
     * @param {boolean|*} value
     * @param {string} [name]
     */
    export function isBoolean(value: any, name?: string): void;
    /**
     *
     * @param {function|*} value
     * @param {string} [name]
     */
    export function isFunction(value: any, name?: string): void;
    /**
     *
     * @param {Object|*} value
     * @param {string} [name]
     */
    export function isObject(value: any, name?: string): void;
    /**
     *
     * @param {number|*} value
     * @param {string} [name]
     */
    export function isInteger(value: any, name?: string): void;
    /**
     *
     * @param {number|*} value
     * @param {string} [name]
     */
    export function isNonNegativeInteger(value: any, name?: string): void;
    /**
     * @template T
     * @param {T[]} value
     * @param {string} name
     */
    export function isArray<T>(value: T[], name?: string): void;
    /**
     * @template T
     * @param {ArrayLike<T>|T[]|Uint32Array|Float32Array} value
     * @param {string} name
     */
    export function isArrayLike<T>(value: Uint32Array | Float32Array | ArrayLike<T> | T[], name?: string): void;
    /**
     * Check for value !== undefined, throws exception if value is undefined
     * @param {*} value
     * @param {String} [name]
     */
    export function defined(value: any, name?: string): void;
    /**
     * Checks for value === undefined, throws exception if value is NOT undefined
     * @param {*} value
     * @param {String} [name]
     */
    export function undefined(value: any, name?: string): void;
    /**
     *
     * @param {*} value
     * @param {String} [name]
     */
    export function isNull(value: any, name?: string): void;
    /**
     *
     * @param {*} value
     * @param {String} [name]
     */
    export function notNull(value: any, name?: string): void;
    /**
     *
     * @param {number} value
     * @param {string} name
     */
    export function notNaN(value: number, name?: string): void;
    /**
     * Is the given number finite?
     * Will trigger if the number is infinite, i.e. fails the `Number.isFinite` test
     * @param {number} value
     * @param {string} [name] optional name for the value being checked
     */
    export function isFinite(value: number, name?: string): void;
    import isFiniteNumber = isFinite;
    export { isFiniteNumber };
    /**
     * More powerful and flexible assertion API based on matchers.
     * Allows complex matching criteria to be constructed.
     *
     * see {@link Matcher}
     * @example
     *  assert.that(value,'value', anyOf(isNull(),isUndefined())); // will trigger iff !(value === undefined || value === null)
     *  assert.that(value, 'value', isOneOf([3,7])); // will only trigger iff !(value === 3 || value === 7)
     *
     * @template T
     * @param {T} value
     * @param {string} name
     * @param {Matcher<T>} matcher
     */
    export function that<T>(value: T, name: string, matcher: Matcher<T>): void;
}
/**
 * @template T
 * @param {T} a
 * @param {T} b
 * @param {string} [m]
 */
declare function notEqual<T>(a: T, b: T, m?: string): void;
/**
 *
 * @param {boolean} t
 * @param {string} [m]
 */
declare function notOk(t: boolean, m?: string): void;
/**
 * @template T
 * @param {T} a
 * @param {T} b
 * @param {string} [m]
 */
declare function equal<T>(a: T, b: T, m?: string): void;
/**
 *
 * @param {object} a
 * @param {object} b
 * @param {string} [m]
 */
declare function logicalEquals(a: object, b: object, m?: string): void;
/**
 *
 * @param {number} a
 * @param {number} b
 * @param {string} [m]
 */
declare function greaterThan(a: number, b: number, m?: string): void;
/**
 *
 * @param {number} a
 * @param {number} b
 * @param {string} [m]
 */
declare function greaterThanOrEqual(a: number, b: number, m?: string): void;
/**
 *
 * @param {number} a
 * @param {number} b
 * @param {string} [m]
 */
declare function lessThan(a: number, b: number, m?: string): void;
/**
 *
 * @param {number} a
 * @param {number} b
 * @param {string} [m]
 */
declare function lessThanOrEqual(a: number, b: number, m?: string): void;
/**
 * Perform a `value typeof === type` check and throw an error if the type does not match.
 * For static cases, prefer to use specific type-checking functions such as {@link assert.isString} or {@link assert.isNumber}.
 * @param {*} value
 * @param {string} type
 * @param {string} valueName
 */
declare function typeOf(value: any, type: string, valueName?: string): void;
/**
 * @template T
 * @param {T[]} haystack
 * @param {T} needle
 * @param {string} [message]
 */
declare function arrayHas<T>(haystack: T[], needle: T, message?: string): void;
/**
 * @template T
 * @param {T[]} haystack
 * @param {T} needle
 * @param {string} [message]
 */
declare function arrayHasNo<T>(haystack: T[], needle: T, message?: string): void;
/**
 * @template T
 * @param {T[]|ArrayLike<T>|Float32Array|Int32Array} a
 * @param {T[]|ArrayLike<T>|Float32Array|Int32Array} b
 * @param {string} [message]
 */
declare function arrayEqual<T>(a: Int32Array | Float32Array | ArrayLike<T> | T[], b: Int32Array | Float32Array | ArrayLike<T> | T[], message?: string): void;
/**
 * @template T
 * @param {T} value
 * @param {T[]} options must be string-serializable for useful error messages
 * @param {string} [name] optional name for a better error message
 */
declare function isOneOf<T>(value: T, options: T[], name?: string): void;
export {};
//# sourceMappingURL=assert.d.ts.map