Documentation v3.0.16

Overview

Utilities contains a set of JavaScript utility functions that can be used in multiple components.

Misc

Function	Description
`escapeHtml()`	Escapes HTML special characters (&'`"<>). Parameters: `str: string` String to escape. Return: `string` Escaped string. `import {utils} from 'metronic-extension'; utils.escapeHtml('I think this is good.');// -> I think this is good. utils.escapeHtml('John "Johnny" Smith');// -> John "Johnny" Smith`
`fetchDataUrl()`	Get the fetched result as a Data URL. Parameters: `url: string\|URL` URL string or URL object. Return: `Promise<string>` Data URL. `import {utils} from 'metronic-extension'; await utils.fetchDataUrl('/img/sample.png');// -> data:image/png;base64,iVBORw0K... await utils.fetchDataUrl('/img/sample.svg');// -> data:image/svg+xml;utf8,%3Csvg...`
`fetchImage()`	Get the fetched result as an Image object. Parameters: `url: string` URL. Return: `Promise<HTMLImageElement>` Image object. `import {utils} from 'metronic-extension'; await utils.fetchImage('/img/1.png');// -> <img crossorigin="use-credentials" src="/img/1.png">`
`formatBytes()`	Convert bytes to strings with units (KB, MB, GB, etc.). Parameters: `bytes: string\|number` Bytes. `decimals?: number` Number of decimal places. Default is 2. `asString?: boolean` If true, returns the result as a string; if false, returns the result as a value and unit object ({val: number, unit: string}). Default is false. Return: `string\|{val: number, unit: string}` Value with units. `import {utils} from 'metronic-extension'; utils.formatBytes(435, 2, true);// -> 435 Bytes utils.formatBytes(490398, 2, true);// -> 478.9 KB utils.formatBytes(23483023, 2, true);// -> 22.4 MB utils.formatBytes(30498505889, 2, true);// -> 28.4 GB utils.formatBytes(9485039485039445, 2, true);// -> 8.42 PB utils.formatBytes(9485039485039445);// -> {val: 8.42, unit: 'PB'}`
`getExtensionFromDataUrl()`	Get extension from Data URL. Parameters: `value: string` Data URL. Return: `string\|null` Extension. For example, jpeg, svg. `import {utils} from 'metronic-extension'; utils.getExtensionFromDataUrl('data:text/html,Hello%2C%20World!');// -> html utils.getExtensionFromDataUrl('data:image/jpeg;base64,/9j/4AAQS');// -> jpeg utils.getExtensionFromDataUrl('data:image/png;base64,iVBORw0KGg');// -> png utils.getExtensionFromDataUrl('data:image/svg+xml;base64,PHN2Zy');// -> svg utils.getExtensionFromDataUrl('data:application/pdf;base64,JVBE');// -> pdf`
`getType()`	Get type name. Parameters: `payload: any` The value to test. Return: `string` Type Name. import {utils} from 'metronic-extension'; utils.getType(3);// -> Number utils.getType(3.4);// -> Number utils.getType(NaN);// -> Number utils.getType('ram');// -> String utils.getType(new String('ram'));// -> String utils.getType(new Date());// -> Date utils.getType(true);// -> Boolean utils.getType(false);// -> Boolean utils.getType(new Boolean(true));// -> Boolean utils.getType({});// -> Object utils.getType(Object.create(null));// -> Object utils.getType({name: 'Narendra'});// -> Object utils.getType(new class Person{});// -> Object utils.getType([]);// -> Array utils.getType(new Array(3, 4));// -> Array utils.getType([3, 4]);// -> Array utils.getType(parseFloat);// -> Function utils.getType(function(){});// -> Function utils.getType(Symbol('foo'));// -> Symbol utils.getType(null);// -> Null utils.getType(undefined);// -> Undefined
`isAsyncFunction()`	Check if it is an asynchronous function. Parameters: `payload: any` The value to test. Return: `boolean` True for asynchronous functions, false otherwise. import {utils} from 'metronic-extension'; utils.isAsyncFunction(async function func() {});// -> true utils.isAsyncFunction(function func() {});// -> false utils.isAsyncFunction(true);// -> false utils.isAsyncFunction(false);// -> false utils.isAsyncFunction(null);// -> false utils.isAsyncFunction(undefined);// -> false utils.isAsyncFunction({});// -> false utils.isAsyncFunction([]);// -> false utils.isAsyncFunction(/a/g);// -> false utils.isAsyncFunction('string');// -> false utils.isAsyncFunction(42);// -> false utils.isAsyncFunction(new Date());// -> false
`isEmpty()`	Check if the value is empty. Parameters: `payload: any` The value to test. Return: `boolean` True for blank, null, undefined, NaN, empty array, empty object, empty File, empty Set, or empty Map; false otherwise. import {utils} from 'metronic-extension'; utils.isEmpty('');// -> true utils.isEmpty(' ');// -> true utils.isEmpty(null);// -> true utils.isEmpty(undefined);// -> true utils.isEmpty(NaN);// -> true utils.isEmpty([]);// -> true utils.isEmpty({});// -> true utils.isEmpty(new Set());// -> true utils.isEmpty(new Map());// -> true utils.isEmpty(new Map());// -> true utils.isEmpty(new File([''], 'foo.txt'));// -> true utils.isEmpty('string');// -> false utils.isEmpty(['a', 'b']);// -> false utils.isEmpty({a: 'b'});// -> false utils.isEmpty(0);// -> false utils.isEmpty(42);// -> false utils.isEmpty(function() {});// -> false utils.isEmpty(false);// -> false utils.isEmpty(true);// -> false utils.isEmpty(new Set([1,2,3]));// -> false utils.isEmpty(new Map([['key', 'value']]));// -> false utils.isEmpty(new File(['bar'], 'bar.txt'));// -> false
`isFunction()`	Check if it is a function. Parameters: `payload: any` The value to test. Return: `boolean` True for function, false otherwise. import {utils} from 'metronic-extension'; utils.isFunction(function func() {});// -> true utils.isFunction(async function func() {});// -> false utils.isFunction(true);// -> false utils.isFunction(false);// -> false utils.isFunction(null);// -> false utils.isFunction(undefined);// -> false utils.isFunction({});// -> false utils.isFunction([]);// -> false utils.isFunction(/a/g);// -> false utils.isFunction('string');// -> false utils.isFunction(42);// -> false utils.isFunction(new Date());// -> false
`isPlainObject()`	Check if it is a plain object created by "{}" or "new Object()". Parameters: `payload: any` The value to test. Return: `boolean` True for function, false otherwise. import {utils} from 'metronic-extension'; utils.isPlainObject({});// -> true utils.isPlainObject({foo: true});// -> true utils.isPlainObject(new Object());// -> true utils.isPlainObject(['foo', 'bar']);// -> false utils.isPlainObject(new class Foo{});// -> false utils.isPlainObject(Math);// -> false utils.isPlainObject(JSON);// -> false utils.isPlainObject(Atomics);// -> false utils.isPlainObject(Error);// -> false utils.isPlainObject(() => {});// -> false utils.isPlainObject(/./);// -> false utils.isPlainObject(null);// -> false utils.isPlainObject(undefined);// -> false utils.isPlainObject(Number.NaN);// -> false utils.isPlainObject('');// -> false utils.isPlainObject(0);// -> false utils.isPlainObject(false);// -> false utils.isPlainObject(Object.create({}));// -> false utils.isPlainObject(Object.create(null));// -> false
`isString()`	Check if it is a string. Parameters: `payload: any` The value to test. Return: `boolean` True if string, false otherwise. `import {utils} from 'metronic-extension'; utils.isString('a');// -> true utils.isString(Object('a'));// -> true utils.isString([1, 2, 3]);// -> false utils.isString(true);// -> false utils.isString(new Date());// -> false utils.isString(new Error());// -> false utils.isString({0: 1, length: 1});// -> false utils.isString(1);// -> false utils.isString(/x/);// -> false utils.isString(Symbol('a'));// -> false`
`utils.isSymbol()`	Checks if the type is Symbol. Parameters: `payload: any` The value to test. Return: `boolean` True if it is a Symbol type, false otherwise. `import {utils} from 'metronic-extension'; utils.isSymbol(Symbol('a'));// -> true utils.isSymbol(Object(Symbol('a')));// -> true utils.isSymbol([1, 2, 3]);// -> false utils.isSymbol(true);// -> false utils.isSymbol(new Date());// -> false utils.isSymbol(new Error());// -> false utils.isSymbol({0: 1, length: 1});// -> false utils.isSymbol(1);// -> false utils.isSymbol(/x/);// -> false utils.isSymbol('a');// -> false`
`numberFormat()`	Number Format (Comma Separation) as per locale. Parameters: `num: string\|number` Numeric value or numeric string. Return: `string` Formatted number. import {utils} from 'metronic-extension'; utils.numberFormat(1234);// -> '1,234' utils.numberFormat(1234.5);// -> '1,234.5' utils.numberFormat(0);// -> '0' utils.numberFormat(.0);// -> '0' utils.numberFormat(-1234);// -> '-1,234' utils.numberFormat(-1234.5);// -> '-1,234.5' utils.numberFormat('1234');// -> '1,234' utils.numberFormat('1234.5');// -> '1,234.5' utils.numberFormat('0');// -> '0' utils.numberFormat('.0');// -> '0' utils.numberFormat('-1234');// -> '-1,234' utils.numberFormat('-1234.5');// -> '-1,234.5'
`trim()`	Trim blanks before and after. Parameters: `str: string\|null\|undefined` String to be trimmed. `toLower?: boolean` If true, the trimmed string is converted to lowercase and returned. Default is false. Return: `string\|null\|undefined` Trimmed string. `import {utils} from 'metronic-extension'; utils.trim(' foo bar ');// -> 'foo bar' utils.trim('\n\n\nfoo bar\n\r\n\n');// -> 'foo bar'`
`urlToMime()`	Get the MIME type inferred from the extension at the end of the URL. Parameters: `url: string` URL string. Return: `string\|null` MIME type inferred from the filename in the URL. `import {utils} from 'metronic-extension'; utils.urlToMime('https://example.com/sample.js');// -> application/javascript utils.urlToMime('https://example.com/sample.json');// -> application/json utils.urlToMime('https://example.com/sample.txt');// -> text/plain utils.urlToMime('https://example.com/sample.jpg');// -> image/jpeg utils.urlToMime('https://example.com/dir/sample.txt');// -> text/plain`

Validator Functions

Function	Description
`isDataURI()`	Check if the data URI format. Parameters: `value: string` Value to be validated. `accept?: string` Comma-separated list of allowed MIME types (e.g., "image/*,application/pdf"). Default is none (undefined). Return: `boolean` Pass is true, fail is false. `import {validators} from 'metronic-extension'; validators.isDataURI('data:text/html,Hello%2C%20World!'); validators.isDataURI('data:image/jpeg;base64,/9j...'); validators.isDataURI('data:image/png;base64,iVB...'); validators.isDataURI('data:image/svg+xml;base64,PHN...'); validators.isDataURI('data:application/pdf;base64,JVB...');`
`isFQDN()`	Check if the domain name is fully qualified (e.g. domain.com). Parameters: `value: string` Value to be validated. `options.requireFQDNTld?: boolean` If true, the TLD is required. Default is true. `options.allowFQDNWildcard?: boolean` If true, the validator will allow domain starting with `.` (e.g. `.example.com` or `.shop.example.com`). Default is false. Return: `boolean` Pass is true, fail is false. `import {validators} from 'metronic-extension'; validators.isFQDN('domain.com'); validators.isFQDN('localhost', {requireFQDNTld: false}); validators.isFQDN('.example.com', {allowFQDNWildcard: true});`
`isFQDNorIP()`	Check for a fully qualified domain name (e.g. domain.com) or IP (version 4 or 6). Parameters: `value: string` Value to be validated. `options.requireFQDNTld?: boolean` If true, the TLD is required. Default is true. `options.allowFQDNWildcard?: boolean` If true, the validator will allow domain starting with `.` (e.g. `.example.com` or `*.shop.example.com`). Default is false. `options.ipVersion?: '4'\|'6'\|4\|6` 4 or 6. The default is undefind (allows both versions 4 and 6). `options.allowIPRange?: boolean` If true, allow IP range input (127.0.0.1/24, 2001::/128, etc.). Default is false. Return: `boolean` Pass is true, fail is false. `import {validators} from 'metronic-extension'; validators.isFQDNorIP('domain.com'); validators.isFQDNorIP('127.0.0.1'); validators.isFQDNorIP('127.0.0.1'); validators.isFQDNorIP('2001:db8:0000:1:1:1:1:1'); validators.isFQDNorIP('1.2.3.4', {ipVersion: 4}); validators.isFQDNorIP('::ffff:127.0.0.1', {ipVersion: 6});`
`isHTML()`	Check if it is HTML. Parameters: `value: string` Value to be validated. Return: `boolean` Pass is true, fail is false. `import {validators} from 'metronic-extension'; validators.isHTML('<p>foo</p>'); validators.isHTML('<a href="#">foo</a>'); validators.isHTML('<x-unicorn>');`
`isIP()`	Check for IP (version 4 or 6). Parameters: `value: string` Value to be validated. `options.ipVersion?: '4'\|'6'\|4\|6` 4 or 6. The default is undefind (allows both versions 4 and 6). `options.allowIPRange?: boolean` If true, allow IP range input (127.0.0.1/24, 2001::/128, etc.). Default is false. Return: `boolean` Pass is true, fail is false. `import {validators} from 'metronic-extension'; validators.isIP('127.0.0.1'); validators.isIP('2001:db8:0000:1:1:1:1:1'); validators.isIP('1.2.3.4', {ipVersion: 4}); validators.isIP('fe80::a6db:30ff:fe98:e946', {ipVersion: 6}); validators.isIP('127.0.0.1/24', {allowIPRange: true}); validators.isIP('2001::/128', {allowIPRange: true});`
`isKana()`	Check if it is katakana (half-width and full-width numbers are also permitted). Parameters: `value: string` Value to be validated. Return: `boolean` Pass is true, fail is false. `import {validators} from 'metronic-extension'; validators.isKana('トウキョウタワー'); validators.isKana('ﾄｳｷｮｳﾀﾜｰ'); validators.isKana('トウキョウﾀﾜｰ'); validators.isKana('トウキョウタワー');`
`isNumericRange()`	Check the range of numbers. Parameters: `value: string` Value to be validated. `options.min: string\|number` Minimum value of the range. Required. `options.max: string\|number` Maximum value of the range. Required. Return: `boolean` Pass is true, fail is false. `import {validators} from 'metronic-extension'; validators.isNumericRange(2, {min: 1, max: 3});`
`isPath()`	Check if it is a file (directory) path Parameters: `value: string` Value to be validated. Return: `boolean` Pass is true, fail is false. `import {validators} from 'metronic-extension'; // With leading slash, without trailing slash. validators.isPath('/'); validators.isPath('/usr'); validators.isPath('/usr/lib'); // With leading and trailing slashes. validators.isPath('/usr/'); validators.isPath('/usr/lib/'); // Without leading slash, with trailing slash. validators.isPath('usr/'); validators.isPath('usr/lib/');`
`isPhoneNumberJp()`	Check if it is a Japanese phone number. Parameters: `value: string` Value to be validated. Return: `boolean` Pass is true, fail is false. `import {validators} from 'metronic-extension'; validators.isPhoneNumberJp('080-1111-1111'); validators.isPhoneNumberJp('080-11111111'); validators.isPhoneNumberJp('08011111111'); validators.isPhoneNumberJp('03-1111-1111'); validators.isPhoneNumberJp('03-11111111'); validators.isPhoneNumberJp('0311111111');`
`isPort()`	Check if it is a port number. Parameters: `value: string` Value to be validated. Return: `boolean` Pass is true, fail is false. `import {validators} from 'metronic-extension'; validators.isPort('0'); validators.isPort('22'); validators.isPort('80'); validators.isPort('443'); validators.isPort('3000'); validators.isPort('8080'); validators.isPort('65535');`
`isUnixUserName()`	Check if it is a unix user name. Parameters: `value: string` Value to be validated. Return: `boolean` Pass is true, fail is false. `import {validators} from 'metronic-extension'; validators.isUnixUserName('root'); validators.isUnixUserName('www-data'); validators.isUnixUserName('user$'); validators.isUnixUserName('user123'); validators.isUnixUserName('_user');`
`isURL()`	Check if it is a URL. Parameters: `value: string` Value to be validated. `options.requireFQDNTld?: boolean` If true, the TLD is required. Default is true. `options.allowFQDNWildcard?: boolean` If true, the validator will allow domain starting with `.` (e.g. `.example.com` or `.shop.example.com`). Default is false. `options.allowFragments?: boolean` If true, allow fragment input. Default is false. `options.allowQueryComponents?: boolean` If true, allow input of query string. Default is false. Return: `boolean` Pass is true, fail is false. import {validators} from 'metronic-extension'; validators.isURL('http://www.foobar.com/'); validators.isURL('HTTP://WWW.FOOBAR.COM/'); validators.isURL('http://www.foobar.com:23/'); validators.isURL('http://www.foobar.com/~foobar'); validators.isURL('http://127.0.0.1/'); validators.isURL('http://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]:80/index.html'); validators.isURL('http://1337.com'); validators.isURL('http://localhost/', {requireFQDNTld: false}); validators.isURL('http://localhost/foo.txt', {requireFQDNTld: false}); validators.isURL('http://127.0.0.1/', {requireFQDNTld: false}); validators.isURL('https://example.com/', {allowFQDNWildcard: true}); validators.isURL('https://.example.com/', {allowFQDNWildcard: true}); validators.isURL('https://www.example.com/*', {allowFQDNWildcard: true});