@schukai/monster 1.30.1 → 2.0.1

package/source/types/is.js

@@ -1,429 +0,0 @@
-'use strict';
-
-/**
- * @author schukai GmbH
- */
-
-import {assignToNamespace, Monster} from '../namespace.js';
-
-/**
- * With this function you can check if a value is iterable.
- * 
- * This method is used in the library to have consistent names.
- *
- * You can call the method via the monster namespace `Monster.Types.isPrimitive()`.
- *
- * ```
- * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/monster.js';
- * Monster.Types.isIterable(null) // ↦ false
- * Monster.Types.isIterable('hello') // ↦ true
- * Monster.Types.isIterable([]) // ↦ true
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {isIterable} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/types/is.js';
- * isIterable(null)  // ↦ false
- * isIterable('hello')  // ↦ true
- * isIterable([])  // ↦ true
- * </script>
- * ```
- *
- * @param {*} value
- * @returns {boolean}
- * @since 1.2.0
- * @copyright schukai GmbH
- * @memberOf Monster.Types
- */
-function isIterable(value) {
-    if (value === undefined) return false;
-    if (value === null) return false;
-    return typeof value?.[Symbol.iterator] === 'function';
-}
-
-
-/**
- * Checks whether the value passed is a primitive (string, number, boolean, NaN, undefined, null or symbol)
- * 
- * This method is used in the library to have consistent names.
- *
- * You can call the method via the monster namespace `Monster.Types.isPrimitive()`.
- *
- * ```
- * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/monster.js';
- * Monster.Types.isPrimitive('2') // ↦ false
- * Monster.Types.isPrimitive([]) // ↦ true
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {isPrimitive} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/types/is.js';
- * isPrimitive('2'))  // ↦ true
- * isPrimitive([]))  // ↦ false
- * </script>
- * ```
- *
- * @param {*} value
- * @returns {boolean}
- * @since 1.0.0
- * @copyright schukai GmbH
- * @memberOf Monster.Types
- */
-function isPrimitive(value) {
-    var type;
-
-    if (value === undefined || value === null) {
-        return true;
-    }
-
-    type = typeof value;
-
-    if (type === 'string' || type === 'number' || type === 'boolean' || type === 'symbol') {
-        return true;
-    }
-
-    return false;
-}
-
-/**
- * Checks whether the value passed is a symbol
- * 
- * This method is used in the library to have consistent names.
- *
- * You can call the method via the monster namespace `Monster.Types.isSymbol()`.
- *
- * ```
- * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/monster.js';
- * Monster.Types.isSymbol('2') // ↦ false
- * Monster.Types.isSymbol(Symbol('test') // ↦ true
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {isSymbol} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/types/is.js';
- * isSymbol(Symbol('a')))  // ↦ true
- * isSymbol([])  // ↦ false
- * </script>
- * ```
- *
- * @param {*} value
- * @returns {boolean}
- * @since 1.9.0
- * @copyright schukai GmbH
- * @memberOf Monster.Types
- */
-function isSymbol(value) {
-    return ('symbol' === typeof value) ? true : false;
-}
-
-/**
- * Checks whether the value passed is a boolean.
- * 
- * This method is used in the library to have consistent names.
- *
- * You can call the method via the monster namespace `Monster.Types.isBoolean()`.
- *
- * ```
- * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/monster.js';
- * Monster.Types.isBoolean('2') // ↦ false
- * Monster.Types.isBoolean([]) // ↦ false
- * Monster.Types.isBoolean(true) // ↦ true
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {isBoolean} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/types/is.js';
- * isBoolean('2'))  // ↦ false
- * isBoolean([]))  // ↦ false
- * isBoolean(2>4))  // ↦ true
- * </script>
- * ```
- *
- * @param {*} value
- * @returns {boolean}
- * @since 1.0.0
- * @copyright schukai GmbH
- * @memberOf Monster.Types
- */
-function isBoolean(value) {
-
-    if (value === true || value === false) {
-        return true;
-    }
-
-    return false;
-}
-
-/**
- * Checks whether the value passed is a string
- * 
- * This method is used in the library to have consistent names.
- *
- * You can call the method via the monster namespace `Monster.Types.isString()`.
- *
- * ```
- * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/monster.js';
- * Monster.Types.isString('2') // ↦ true
- * Monster.Types.isString([]) // ↦ false
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {isString} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/types/is.js';
- * isString('2'))  // ↦ true
- * isString([]))  // ↦ false
- * </script>
- * ```
- *
- * @param {*} value
- * @returns {boolean}
- * @since 1.0.0
- * @copyright schukai GmbH
- * @memberOf Monster.Types
- */
-function isString(value) {
-    if (value === undefined || typeof value !== 'string') {
-        return false;
-    }
-    return true;
-}
-
-/**
- * Checks whether the value passed is a object
- * 
- * This method is used in the library to have consistent names.
- *
- * You can call the method via the monster namespace `Monster.Types.isObject()`.
- *
- * ```
- * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/monster.js';
- * Monster.Types.isObject('2') // ↦ false
- * Monster.Types.isObject([]) // ↦ false
- * Monster.Types.isObject({}) // ↦ true
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {isObject} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/types/is.js';
- * isObject('2'))  // ↦ false
- * isObject([]))  // ↦ false
- * </script>
- * ```
- *
- * @param {*} value
- * @returns {boolean}
- * @since 1.0.0
- * @copyright schukai GmbH
- * @memberOf Monster.Types
- */
-function isObject(value) {
-
-    if (isArray(value)) return false;
-    if (isPrimitive(value)) return false;
-
-    if (typeof value === 'object') {
-        return true;
-    }
-
-    return false;
-}
-
-/**
- * Checks whether the value passed is a object and instance of instance.
- * 
- * This method is used in the library to have consistent names.
- *
- * you can call the method via the monster namespace `Monster.Types.isInstance()`.
- *
- * ```
- * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/monster.js';
- * Monster.Types.isInstance('2') // ↦ false
- * Monster.Types.isInstance([]) // ↦ false
- * Monster.Types.isInstance({}) // ↦ true
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {isInstance} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/types/is.js';
- * isInstance('2'))  // ↦ false
- * isInstance([]))  // ↦ false
- * </script>
- * ```
- *
- * @param {*} value
- * @param {*} instance
- * @returns {boolean}
- * @since 1.5.0
- * @copyright schukai GmbH
- * @memberOf Monster.Types
- */
-function isInstance(value, instance) {
-
-    if (!isObject(value)) return false;
-    if (!isFunction(instance)) return false;
-    if (!instance.hasOwnProperty('prototype')) return false;
-    return (value instanceof instance) ? true : false;
-
-}
-
-/**
- * Checks whether the value passed is a array
- * 
- * This method is used in the library to have consistent names. 
- *
- * you can call the method via the monster namespace `Monster.Types.isArray()`.
- *
- * ```
- * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/monster.js';
- * Monster.Types.isArray('2') // ↦ false
- * Monster.Types.isArray([]) // ↦ true
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {isArray} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/types/is.js';
- * isArray('2'))  // ↦ false
- * isArray([]))  // ↦ true
- * </script>
- * ```
- *
- * @param {*} value
- * @returns {boolean}
- * @since 1.0.0
- * @copyright schukai GmbH
- * @memberOf Monster.Types
- * @see https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray
- */
-function isArray(value) {
-    return Array.isArray(value);
-}
-
-/**
- * Checks whether the value passed is a function
- * 
- * This method is used in the library to have consistent names. 
- *
- * you can call the method via the monster namespace `Monster.Types.isFunction()`.
- *
- * ```
- * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/monster.js';
- * Monster.Types.isFunction(()=>{}) // ↦ true
- * Monster.Types.isFunction('2') // ↦ false
- * Monster.Types.isFunction([]) // ↦ false
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {isFunction} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/types/is.js';
- * isFunction(()=>{}) // ↦ true
- * isFunction('2'))  // ↦ false
- * isFunction([]))  // ↦ false
- * </script>
- * ```
- *
- * @param {*} value
- * @returns {boolean}
- * @since 1.0.0
- * @copyright schukai GmbH
- * @memberOf Monster.Types
- */
-function isFunction(value) {
-    if (isArray(value)) return false;
-    if (isPrimitive(value)) return false;
-
-    if (typeof value === 'function') {
-        return true;
-    }
-
-    return false;
-
-}
-
-/**
- * Checks whether the value passed is an integer.
- * 
- * This method is used in the library to have consistent names. 
- *
- * You can call the method via the monster namespace `Monster.Types.isFunction()`.
- *
- * ```
- * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/monster.js';
- * Monster.Types.isInteger(()=>{}) // ↦ true
- * Monster.Types.isInteger('2') // ↦ false
- * Monster.Types.isInteger(2) // ↦ true
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {isInteger} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/types/is.js';
- * isInteger(()=>{}) // ↦ true
- * isInteger('2'))  // ↦ false
- * isInteger(2))  // ↦ true
- * </script>
- * ```
- *
- * @param {*} value
- * @returns {boolean}
- * @since 1.4.0
- * @copyright schukai GmbH
- * @memberOf Monster.Types
- */
-function isInteger(value) {
-    return Number.isInteger(value);
-}
-
-
-assignToNamespace('Monster.Types', isPrimitive, isBoolean, isString, isObject, isArray, isFunction, isIterable, isInteger, isSymbol);
-export {
-    Monster,
-    isPrimitive,
-    isBoolean,
-    isString,
-    isObject,
-    isInstance,
-    isArray,
-    isFunction,
-    isIterable,
-    isInteger,
-    isSymbol
-}

package/source/types/package.d.ts

@@ -1 +0,0 @@
-export declare let Monster: Object;

package/source/types/randomid.js

@@ -1,60 +0,0 @@
-'use strict';
-
-import {random} from "../math/random.js";
-/**
- * @author schukai GmbH
- */
-import {assignToNamespace, Monster} from '../namespace.js';
-import {getGlobal} from "./global.js";
-import {ID} from "./id.js";
-
-/**
- * @private
- * @type {number}
- */
-let internalCounter = 0;
-
-/**
- * You can call the method via the monster namespace `new Monster.Types.RandomID()`.
- *
- * ```
- * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/monster.js';
- * console.log(new Monster.Types.RandomID())
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {RandomID} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/types/randomid.js';
- * console.log(new RandomID())
- * </script>
- * ```
- *
- * @since 1.6.0
- * @copyright schukai GmbH
- * @memberOf Monster.Types
- * @summary class to generate random numbers
- */
-class RandomID extends ID {
-
-    /**
-     * create new object
-     */
-    constructor() {
-        super();
-
-        internalCounter += 1;
-
-        this.id = getGlobal().btoa(random(1, 10000))
-            .replace(/=/g, '')
-            /** No numbers at the beginning of the ID, because of possible problems with DOM */
-            .replace(/^[0-9]+/, 'X') + internalCounter;
-    }
-
-}
-
-assignToNamespace('Monster.Types', RandomID);
-export {Monster, RandomID}

package/source/types/regex.js

@@ -1,49 +0,0 @@
-'use strict';
-
-/**
- * @author schukai GmbH
- */
-
-
-import {assignToNamespace, Monster} from "../namespace.js";
-import {validateString} from "./validate.js";
-
-/**
- * This function prefixes all special characters that may appear in a regex with a slash.
- * 
- * You can call the method via the monster namespace `Monster.Types.escapeString()`.
- *
- * ```
- * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/monster.js';
- * Monster.Types.escapeString()
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {escapeString} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/types/validate.js';
- * escapeString()
- * </script>
- * ```
- *
- * @param {string} value
- * @return {string}
- * @since 1.26.0
- * @copyright schukai GmbH
- * @memberOf Monster.Types
- * @throws {TypeError} value is not a string
- */
-function escapeString(value) {
-    return validateString(value)
-        .replace(/[|\\{}()[\]^$+*?.]/g, '\\$&')
-        .replace(/-/g, '\\x2d');
-}
-
-assignToNamespace('Monster.Types', escapeString);
-export {
-    Monster,
-    escapeString
-}

package/source/types/typeof.js

@@ -1,63 +0,0 @@
-'use strict';
-
-/**
- * @author schukai GmbH
- */
-
-
-import {assignToNamespace, Monster} from '../namespace.js';
-
-/**
- * The built-in typeof method is known to have some historical weaknesses. This function tries to provide a better and more accurate result.
- *
- * You can call the method via the monster namespace `Monster.Types.typeOf()`.
- *
- * ```
- * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/monster.js';
- * console.log(Monster.Types.typeOf())
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {typeOf} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/types/typeof.js';
- * console.log(typeOf())
- * </script>
- * ```
- *
- * @example
- *
- * import {typeOf} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/types/typeof.js';
- *
- * console.log(typeOf(undefined)); // ↦ undefined
- * console.log(typeOf("")); // ↦ string
- * console.log(typeOf(5)); // ↦ number
- * console.log(typeOf({})); // ↦ object
- * console.log(typeOf([])); // ↦ array
- * console.log(typeOf(new Map)); // ↦ map
- * console.log(typeOf(true)); // ↦ boolean
- *
- * @param {*} value
- * @return {string}
- * @since 1.7.0
- * @copyright schukai GmbH
- * @memberOf Monster.Types
- * @throws {TypeError} value is not a primitive
- */
-function typeOf(value) {
-    let type = ({}).toString.call(value).match(/\s([a-zA-Z]+)/)[1];
-    if ('Object' === type) {
-        const results = (/^(class|function)\s+(\w+)/).exec(value.constructor.toString());
-        type = (results && results.length > 2) ? results[2] : '';
-    }
-    return type.toLowerCase();
-}
-
-assignToNamespace('Monster.Types', typeOf);
-export {
-    Monster,
-    typeOf
-}

package/source/util/freeze.js

@@ -1,57 +0,0 @@
-'use strict';
-
-/**
- * @author schukai GmbH
- */
-
-import {assignToNamespace, Monster} from '../namespace.js';
-import {validateObject} from '../types/validate.js';
-
-/**
- * Deep freeze a object
- *
- * You can call the method via the monster namespace `Monster.Util.deepFreeze()`.
- *
- * ```
- * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/monster.js';
- * Monster.Util.deepFreeze({})
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {deepFreeze} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/util/freeze.js';
- * deepFreeze({})
- * </script>
- * ```
- *
- * @param {object} object object to be freeze
- * @since 1.0.0
- * @returns {object}
- * @memberOf Monster.Util
- * @copyright schukai GmbH
- * @throws {TypeError} value is not a object
- */
-function deepFreeze(object) {
-
-    validateObject(object)
-
-    // Retrieve the defined property names of the object
-    var propNames = Object.getOwnPropertyNames(object);
-
-    // Freeze properties before freezing yourself
-    for (let name of propNames) {
-        let value = object[name];
-
-        object[name] = (value && typeof value === "object") ?
-            deepFreeze(value) : value;
-    }
-
-    return Object.freeze(object);
-}
-
-assignToNamespace('Monster.Util', deepFreeze);
-export {Monster, deepFreeze}