skapi-js 0.2.0 → 0.2.2

package/js/utils/utils.d.ts

@@ -0,0 +1,20 @@
+import { Form } from "../Types";
+declare class MD5 {
+    private static readonly alphabet;
+    static hash(str?: string): string;
+    private static rh;
+    private static ad;
+    private static rl;
+    private static cm;
+    private static ff;
+    private static gg;
+    private static hh;
+    private static ii;
+    private static sb;
+}
+declare function generateRandom(length?: number): string;
+declare function extractFormMeta(form: Form<any>): {
+    meta: {};
+    files: any[];
+};
+export { extractFormMeta, MD5, generateRandom };

package/js/utils/utils.js

@@ -0,0 +1,286 @@
+import SkapiError from "../main/error";
+class MD5 {
+    static hash(str) {
+        if (typeof str !== 'string') {
+            console.warn('coercing non-string value to empty string');
+            str = '';
+        }
+        const x = MD5.sb(str);
+        let a = 1732584193;
+        let b = -271733879;
+        let c = -1732584194;
+        let d = 271733878;
+        let lastA;
+        let lastB;
+        let lastC;
+        let lastD;
+        for (let i = 0; i < x.length; i += 16) {
+            lastA = a;
+            lastB = b;
+            lastC = c;
+            lastD = d;
+            a = MD5.ff(a, b, c, d, x[i], 7, -680876936);
+            d = MD5.ff(d, a, b, c, x[i + 1], 12, -389564586);
+            c = MD5.ff(c, d, a, b, x[i + 2], 17, 606105819);
+            b = MD5.ff(b, c, d, a, x[i + 3], 22, -1044525330);
+            a = MD5.ff(a, b, c, d, x[i + 4], 7, -176418897);
+            d = MD5.ff(d, a, b, c, x[i + 5], 12, 1200080426);
+            c = MD5.ff(c, d, a, b, x[i + 6], 17, -1473231341);
+            b = MD5.ff(b, c, d, a, x[i + 7], 22, -45705983);
+            a = MD5.ff(a, b, c, d, x[i + 8], 7, 1770035416);
+            d = MD5.ff(d, a, b, c, x[i + 9], 12, -1958414417);
+            c = MD5.ff(c, d, a, b, x[i + 10], 17, -42063);
+            b = MD5.ff(b, c, d, a, x[i + 11], 22, -1990404162);
+            a = MD5.ff(a, b, c, d, x[i + 12], 7, 1804603682);
+            d = MD5.ff(d, a, b, c, x[i + 13], 12, -40341101);
+            c = MD5.ff(c, d, a, b, x[i + 14], 17, -1502002290);
+            b = MD5.ff(b, c, d, a, x[i + 15], 22, 1236535329);
+            a = MD5.gg(a, b, c, d, x[i + 1], 5, -165796510);
+            d = MD5.gg(d, a, b, c, x[i + 6], 9, -1069501632);
+            c = MD5.gg(c, d, a, b, x[i + 11], 14, 643717713);
+            b = MD5.gg(b, c, d, a, x[i], 20, -373897302);
+            a = MD5.gg(a, b, c, d, x[i + 5], 5, -701558691);
+            d = MD5.gg(d, a, b, c, x[i + 10], 9, 38016083);
+            c = MD5.gg(c, d, a, b, x[i + 15], 14, -660478335);
+            b = MD5.gg(b, c, d, a, x[i + 4], 20, -405537848);
+            a = MD5.gg(a, b, c, d, x[i + 9], 5, 568446438);
+            d = MD5.gg(d, a, b, c, x[i + 14], 9, -1019803690);
+            c = MD5.gg(c, d, a, b, x[i + 3], 14, -187363961);
+            b = MD5.gg(b, c, d, a, x[i + 8], 20, 1163531501);
+            a = MD5.gg(a, b, c, d, x[i + 13], 5, -1444681467);
+            d = MD5.gg(d, a, b, c, x[i + 2], 9, -51403784);
+            c = MD5.gg(c, d, a, b, x[i + 7], 14, 1735328473);
+            b = MD5.gg(b, c, d, a, x[i + 12], 20, -1926607734);
+            a = MD5.hh(a, b, c, d, x[i + 5], 4, -378558);
+            d = MD5.hh(d, a, b, c, x[i + 8], 11, -2022574463);
+            c = MD5.hh(c, d, a, b, x[i + 11], 16, 1839030562);
+            b = MD5.hh(b, c, d, a, x[i + 14], 23, -35309556);
+            a = MD5.hh(a, b, c, d, x[i + 1], 4, -1530992060);
+            d = MD5.hh(d, a, b, c, x[i + 4], 11, 1272893353);
+            c = MD5.hh(c, d, a, b, x[i + 7], 16, -155497632);
+            b = MD5.hh(b, c, d, a, x[i + 10], 23, -1094730640);
+            a = MD5.hh(a, b, c, d, x[i + 13], 4, 681279174);
+            d = MD5.hh(d, a, b, c, x[i], 11, -358537222);
+            c = MD5.hh(c, d, a, b, x[i + 3], 16, -722521979);
+            b = MD5.hh(b, c, d, a, x[i + 6], 23, 76029189);
+            a = MD5.hh(a, b, c, d, x[i + 9], 4, -640364487);
+            d = MD5.hh(d, a, b, c, x[i + 12], 11, -421815835);
+            c = MD5.hh(c, d, a, b, x[i + 15], 16, 530742520);
+            b = MD5.hh(b, c, d, a, x[i + 2], 23, -995338651);
+            a = MD5.ii(a, b, c, d, x[i], 6, -198630844);
+            d = MD5.ii(d, a, b, c, x[i + 7], 10, 1126891415);
+            c = MD5.ii(c, d, a, b, x[i + 14], 15, -1416354905);
+            b = MD5.ii(b, c, d, a, x[i + 5], 21, -57434055);
+            a = MD5.ii(a, b, c, d, x[i + 12], 6, 1700485571);
+            d = MD5.ii(d, a, b, c, x[i + 3], 10, -1894986606);
+            c = MD5.ii(c, d, a, b, x[i + 10], 15, -1051523);
+            b = MD5.ii(b, c, d, a, x[i + 1], 21, -2054922799);
+            a = MD5.ii(a, b, c, d, x[i + 8], 6, 1873313359);
+            d = MD5.ii(d, a, b, c, x[i + 15], 10, -30611744);
+            c = MD5.ii(c, d, a, b, x[i + 6], 15, -1560198380);
+            b = MD5.ii(b, c, d, a, x[i + 13], 21, 1309151649);
+            a = MD5.ii(a, b, c, d, x[i + 4], 6, -145523070);
+            d = MD5.ii(d, a, b, c, x[i + 11], 10, -1120210379);
+            c = MD5.ii(c, d, a, b, x[i + 2], 15, 718787259);
+            b = MD5.ii(b, c, d, a, x[i + 9], 21, -343485551);
+            a = MD5.ad(a, lastA);
+            b = MD5.ad(b, lastB);
+            c = MD5.ad(c, lastC);
+            d = MD5.ad(d, lastD);
+        }
+        return MD5.rh(a) + MD5.rh(b) + MD5.rh(c) + MD5.rh(d);
+    }
+    static rh(n) {
+        let s = '';
+        for (let j = 0; j <= 3; j++) {
+            s += MD5.alphabet.charAt((n >> (j * 8 + 4)) & 0x0F) + MD5.alphabet.charAt((n >> (j * 8)) & 0x0F);
+        }
+        return s;
+    }
+    static ad(x, y) {
+        const l = (x & 0xFFFF) + (y & 0xFFFF);
+        const m = (x >> 16) + (y >> 16) + (l >> 16);
+        return (m << 16) | (l & 0xFFFF);
+    }
+    static rl(n, c) {
+        return (n << c) | (n >>> (32 - c));
+    }
+    static cm(q, a, b, x, s, t) {
+        return MD5.ad(MD5.rl(MD5.ad(MD5.ad(a, q), MD5.ad(x, t)), s), b);
+    }
+    static ff(a, b, c, d, x, s, t) {
+        return MD5.cm(b & c | ~b & d, a, b, x, s, t);
+    }
+    static gg(a, b, c, d, x, s, t) {
+        return MD5.cm(b & d | c & ~d, a, b, x, s, t);
+    }
+    static hh(a, b, c, d, x, s, t) {
+        return MD5.cm(b ^ c ^ d, a, b, x, s, t);
+    }
+    static ii(a, b, c, d, x, s, t) {
+        return MD5.cm(c ^ (b | ~d), a, b, x, s, t);
+    }
+    static sb(x) {
+        let i;
+        const numBlocks = ((x.length + 8) >> 6) + 1;
+        const blocks = new Array(numBlocks * 16);
+        for (i = 0; i < numBlocks * 16; i++) {
+            blocks[i] = 0;
+        }
+        for (i = 0; i < x.length; i++) {
+            blocks[i >> 2] |= x.charCodeAt(i) << ((i % 4) * 8);
+        }
+        blocks[i >> 2] |= 0x80 << ((i % 4) * 8);
+        blocks[numBlocks * 16 - 2] = x.length * 8;
+        return blocks;
+    }
+}
+MD5.alphabet = '0123456789abcdef';
+function generateRandom(length = 6) {
+    let result = '';
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const charactersLength = characters.length;
+    let counter = 0;
+    while (counter < length) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+        counter += 1;
+    }
+    return result;
+}
+function extractFormMeta(form) {
+    function appendData(meta, key, val) {
+        let fchar = key.slice(0, 1);
+        let lchar = key.slice(-1);
+        if (fchar === '.') {
+            key = key.slice(1);
+        }
+        if (lchar === '.') {
+            key = key.slice(0, -1);
+        }
+        if (key.includes('.')) {
+            let nestKey = key.split('.');
+            key = nestKey.pop();
+            for (let k of nestKey) {
+                if (!k) {
+                    continue;
+                }
+                if (!meta.hasOwnProperty(k)) {
+                    meta[k] = {};
+                }
+                meta = meta[k];
+            }
+        }
+        if (meta.hasOwnProperty(key)) {
+            if (Array.isArray(meta[key])) {
+                meta[key].push(val);
+            }
+            else {
+                meta[key] = [meta[key], val];
+            }
+        }
+        else {
+            meta[key] = val;
+        }
+    }
+    if (form instanceof FormData) {
+        let meta = {};
+        let totalFileSize = 0;
+        let files = [];
+        for (let pair of form.entries()) {
+            let name = pair[0];
+            let v = pair[1];
+            if (v instanceof File) {
+                if (!files.includes(name)) {
+                    files.push(name);
+                }
+                totalFileSize += v.size;
+            }
+            else if (v instanceof FileList) {
+                if (!files.includes(name)) {
+                    files.push(name);
+                }
+                if (v && v.length > 0) {
+                    for (let idx = 0; idx <= v.length - 1; idx++) {
+                        totalFileSize += v.item(idx).size;
+                    }
+                }
+            }
+            else {
+                appendData(meta, name, v);
+            }
+        }
+        if (totalFileSize > 4400000) {
+            throw new SkapiError('Total File size cannot exceed 4MB. Use skapi.uploadFiles() instead.', { code: 'INVALID_REQUEST' });
+        }
+        return { meta, files };
+    }
+    if (form instanceof SubmitEvent) {
+        form = form.target;
+    }
+    if (form instanceof HTMLFormElement) {
+        let meta = {};
+        let files = [];
+        let totalFileSize = 0;
+        let inputs = form.querySelectorAll('input');
+        let textarea = form.querySelectorAll('textarea');
+        for (let idx = 0; idx < textarea.length; idx++) {
+            let i = textarea[idx];
+            if (i.name) {
+                appendData(meta, i.name, i.value);
+            }
+        }
+        for (let idx = 0; idx < inputs.length; idx++) {
+            let i = inputs[idx];
+            if (i.name) {
+                if (i.type === 'number') {
+                    if (i.value) {
+                        appendData(meta, i.name, Number(i.value));
+                    }
+                }
+                else if (i.type === 'checkbox' || i.type === 'radio') {
+                    if (i.checked) {
+                        if (i.value === '' && i.type === 'checkbox' || i.value === 'on' || i.value === 'true') {
+                            appendData(meta, i.name, true);
+                        }
+                        else if (i.value === 'false') {
+                            appendData(meta, i.name, false);
+                        }
+                        else if (i.value) {
+                            appendData(meta, i.name, i.value);
+                        }
+                    }
+                    else if (i.type === 'checkbox') {
+                        if (i.value === '' || i.value === 'on' || i.value === 'true') {
+                            appendData(meta, i.name, false);
+                        }
+                        else if (i.value === 'false') {
+                            appendData(meta, i.name, true);
+                        }
+                        else {
+                            appendData(meta, i.name, undefined);
+                        }
+                    }
+                }
+                else if (i.type === 'file') {
+                    if (!files.includes(i.name)) {
+                        files.push(i.name);
+                    }
+                    if (i.files && i.files.length > 0) {
+                        for (let idx = 0; idx <= i.files.length - 1; idx++) {
+                            totalFileSize += i.files.item(idx).size;
+                        }
+                    }
+                }
+                else {
+                    appendData(meta, i.name, i.value);
+                }
+            }
+        }
+        if (totalFileSize > 4400000) {
+            throw new SkapiError('Total File size cannot exceed 4MB. Use skapi.uploadFiles() instead.', { code: 'INVALID_REQUEST' });
+        }
+        return { meta, files };
+    }
+    return null;
+}
+export { extractFormMeta, MD5, generateRandom };

package/js/utils/validator.d.ts

@@ -0,0 +1,19 @@
+declare function UserId(id: string, param?: string): string;
+declare function PhoneNumber(value: string): string;
+declare function Birthdate(birthdate: string): string;
+declare function Password(password: string): string;
+declare function Email(email: string, paramName?: string): string;
+declare function Url(url: string | string[]): any;
+declare function specialChars(string: string | string[], p?: string, allowPeriods?: boolean, allowWhiteSpace?: boolean): string | string[];
+declare function Params(params: any, struct: Record<string, any>, required?: string[] | null, bypassCheck?: string[] | null, _parentKey?: string | null): any;
+declare const _default: {
+    UserId: typeof UserId;
+    PhoneNumber: typeof PhoneNumber;
+    Birthdate: typeof Birthdate;
+    Password: typeof Password;
+    Email: typeof Email;
+    Url: typeof Url;
+    specialChars: typeof specialChars;
+    Params: typeof Params;
+};
+export default _default;

package/js/utils/validator.js

@@ -0,0 +1,294 @@
+import SkapiError from '../main/error';
+import { extractFormMeta } from './utils';
+function UserId(id, param = 'User ID') {
+    let uuid_regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    if (!id) {
+        throw new SkapiError(`${param} is empty.`, { code: 'INVALID_PARAMETER' });
+    }
+    else if (typeof id !== 'string') {
+        throw new SkapiError(`${param} should be type: string.`, { code: 'INVALID_PARAMETER' });
+    }
+    else if (!id.match(uuid_regex)) {
+        throw new SkapiError(`${param} is invalid.`, { code: 'INVALID_PARAMETER' });
+    }
+    return id;
+}
+function PhoneNumber(value) {
+    if (value) {
+        if (typeof value !== 'string' || value.charAt(0) !== '+' || isNaN(Number(value.substring(1)))) {
+            throw new SkapiError('"phone_number" is invalid. The format should be "+00123456789". Type: string.', { code: 'INVALID_PARAMETER' });
+        }
+    }
+    return value || '';
+}
+function Birthdate(birthdate) {
+    if (birthdate) {
+        if (typeof birthdate !== 'string') {
+            throw new SkapiError('"birthdate" is invalid. The format should be "yyyy-mm-dd". Type: string.', { code: 'INVALID_PARAMETER' });
+        }
+        else {
+            let date_regex = new RegExp(/([12]\d{3}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01]))/);
+            if (birthdate.length !== 10 || birthdate.split('-').length !== 3 || !date_regex.test(birthdate)) {
+                throw new SkapiError('"birthdate" is invalid. The format should be "yyyy-mm-dd". Type: string.', { code: 'INVALID_PARAMETER' });
+            }
+        }
+    }
+    return birthdate || '';
+}
+function Password(password) {
+    if (!password) {
+        throw new SkapiError('"password" is required.', { code: 'INVALID_PARAMETER' });
+    }
+    else if (typeof password !== 'string') {
+        throw new SkapiError('"password" should be type: string.', { code: 'INVALID_PARAMETER' });
+    }
+    else if (password.length < 6) {
+        throw new SkapiError('"password" should be at least 6 characters.', { code: 'INVALID_PARAMETER' });
+    }
+    else if (password.length > 60) {
+        throw new SkapiError('"password" can be up to 60 characters max.', { code: 'INVALID_PARAMETER' });
+    }
+    return password;
+}
+function Email(email, paramName = 'email') {
+    if (!email) {
+        throw new SkapiError(`"${paramName}" is required.`, { code: 'INVALID_PARAMETER' });
+    }
+    else if (typeof email !== 'string') {
+        throw new SkapiError(`"${paramName}"should be type: string.`, { code: 'INVALID_PARAMETER' });
+    }
+    else if (email.length < 5) {
+        throw new SkapiError(`"${paramName}" should be at least 5 characters.`, { code: 'INVALID_PARAMETER' });
+    }
+    else if (/^[a-zA-Z0-9.!#$%&'+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z]+[a-zA-Z0-9-]+)$/.test(email)) {
+        email = email.trim();
+        let splitAt = email.split('@');
+        let tld = splitAt[1].split('.');
+        if (tld.length >= 2) {
+            return email.toLowerCase();
+        }
+    }
+    throw new SkapiError(`"${email}" is an invalid email.`, { code: 'INVALID_PARAMETER' });
+}
+function Url(url) {
+    const baseUrl = (() => {
+        let baseUrl = window.location.origin || null;
+        if (baseUrl && baseUrl.slice(-1) === '/') {
+            baseUrl = baseUrl.slice(0, -1);
+        }
+        return baseUrl;
+    })();
+    let check = (c) => {
+        if (typeof c === 'string') {
+            if (c === '*') {
+                return '*';
+            }
+            else {
+                let cu = c.trim();
+                if (!cu.includes(' ') && !cu.includes(',')) {
+                    if (cu.slice(0, 1) === '/' && baseUrl) {
+                        cu = baseUrl + cu;
+                    }
+                    else if (cu.slice(0, 1) === '.' && baseUrl) {
+                        cu = window.location.href.split('/').slice(0, -1).join('/') + cu;
+                    }
+                    let _url;
+                    try {
+                        _url = new URL(cu);
+                    }
+                    catch (err) {
+                        throw new SkapiError(`"${c}" is an invalid url.`, { code: 'INVALID_PARAMETER' });
+                    }
+                    if (_url.protocol) {
+                        let url = _url.href;
+                        if (url.charAt(url.length - 1) === '/')
+                            url = url.substring(0, url.length - 1);
+                        return url;
+                    }
+                }
+            }
+        }
+        throw new SkapiError(`"${c}" is an invalid url.`, { code: 'INVALID_PARAMETER' });
+    };
+    if (Array.isArray(url)) {
+        return url.map(u => check(u));
+    }
+    else {
+        return check(url);
+    }
+}
+function specialChars(string, p = 'parameter', allowPeriods = false, allowWhiteSpace = false) {
+    let checkStr = (s) => {
+        if (typeof s !== 'string') {
+            throw new SkapiError(`${p} should be type: <string | string[]>.`, { code: 'INVALID_PARAMETER' });
+        }
+        if (!allowWhiteSpace && string.includes(' ')) {
+            throw new SkapiError(`${p} should not have whitespace.`, { code: 'INVALID_PARAMETER' });
+        }
+        if (!allowPeriods && string.includes('.')) {
+            throw new SkapiError(`${p} should not have periods.`, { code: 'INVALID_PARAMETER' });
+        }
+        if (/[`!@#$%^&*()_+\-=\[\]{};':"\\|,<>\/?~]/.test(s)) {
+            throw new SkapiError(`${p} should not have special characters.`, { code: 'INVALID_PARAMETER' });
+        }
+    };
+    if (Array.isArray(string)) {
+        for (let s of string) {
+            checkStr(s);
+        }
+    }
+    else {
+        checkStr(string);
+    }
+    return string;
+}
+function Params(params, struct, required = null, bypassCheck = [], _parentKey = null) {
+    if (Array.isArray(bypassCheck)) {
+        bypassCheck = bypassCheck.concat([
+            'service',
+            'owner',
+        ]);
+    }
+    function isObjectWithKeys(obj) {
+        if (obj instanceof Promise) {
+            throw new SkapiError('Parameter should not be a promise', { code: 'INVALID_PARAMETER' });
+        }
+        return obj && typeof obj === 'object' && !Array.isArray(obj) && Object.keys(obj).length;
+    }
+    function isEmptyObject(obj) {
+        return obj && typeof obj === 'object' && !Array.isArray(obj) && !Object.keys(obj).length;
+    }
+    let _params = params;
+    let val;
+    let errToThrow = null;
+    let isInvalid = _parentKey ? ` in "${_parentKey}" is invalid.` : '. Parameter should be type <object>.';
+    if (_parentKey === null) {
+        if (isObjectWithKeys(_params)) {
+            if (_params instanceof HTMLFormElement || _params instanceof FormData || _params instanceof SubmitEvent) {
+                _params = extractFormMeta(params)?.meta;
+            }
+            else {
+                _params = JSON.parse(JSON.stringify(params));
+            }
+            for (let k in _params) {
+                if (!struct.hasOwnProperty(k) && Array.isArray(bypassCheck) && !bypassCheck.includes(k)) {
+                    throw new SkapiError(`Key name "${k}" is invalid in parameter.`, { code: 'INVALID_PARAMETER' });
+                }
+            }
+            if (Array.isArray(required) && required.length) {
+                for (let k of required) {
+                    if (!Object.keys(_params).includes(k)) {
+                        throw new SkapiError(`Key "${k}" is required in parameter.`, { code: 'INVALID_PARAMETER' });
+                    }
+                }
+            }
+        }
+        else if (isEmptyObject(_params) || typeof _params === 'undefined') {
+            let defaults = {};
+            for (let s in struct) {
+                let structValue = struct[s];
+                if (Array.isArray(structValue) && typeof structValue[structValue.length - 1] === 'function')
+                    defaults[s] = structValue[structValue.length - 1]();
+            }
+            return Object.keys(defaults).length ? defaults : _params;
+        }
+        if (_params === null) {
+            return null;
+        }
+    }
+    if (isObjectWithKeys(struct) && isObjectWithKeys(_params)) {
+        for (let s in struct) {
+            let structValue = struct[s];
+            if (_params.hasOwnProperty(s) && _params[s] === null) {
+                _params[s] = null;
+            }
+            else if (_params.hasOwnProperty(s) && typeof _params[s] !== 'undefined') {
+                _params[s] = Params(_params[s], structValue, null, null, s);
+            }
+            else {
+                let defaultSetter = Array.isArray(structValue) &&
+                    typeof structValue[structValue.length - 1] === 'function' ? structValue[structValue.length - 1] : null;
+                if (defaultSetter) {
+                    let def = defaultSetter();
+                    if (def !== undefined) {
+                        _params[s] = def;
+                    }
+                }
+            }
+        }
+        val = _params;
+    }
+    else if (Array.isArray(struct)) {
+        for (let s of struct) {
+            try {
+                if (typeof _params !== undefined && typeof s !== 'function') {
+                    val = Params(_params, s, null, null, _parentKey);
+                }
+                break;
+            }
+            catch (err) {
+                if (typeof err === 'string' && err.substring(0, 6) === 'BREAK:') {
+                    err = err.substring(6);
+                    let errMsg = err.split(':');
+                    errToThrow = new SkapiError(errMsg[1], { code: errMsg[0] });
+                    break;
+                }
+                else {
+                    errToThrow = err;
+                }
+            }
+        }
+    }
+    else if (typeof struct === 'function') {
+        return struct(_params);
+    }
+    else if (typeof struct === 'string') {
+        if (Array.isArray(_params)) {
+            if (struct !== 'array') {
+                throw new SkapiError(`Invalid type "${typeof _params}"${isInvalid}`, { code: 'INVALID_PARAMETER' });
+            }
+            for (let p of _params) {
+                if (!['number', 'string', 'boolean'].includes(typeof p) && p !== null) {
+                    throw new SkapiError(`Invalid type "${typeof p}" in "${_parentKey}" array value.`, { code: 'INVALID_PARAMETER' });
+                }
+            }
+            val = _params;
+        }
+        else if (!['number', 'string', 'boolean', 'array', 'function'].includes(struct)) {
+            if (_params === struct) {
+                val = _params;
+            }
+            else {
+                throw new SkapiError(`Value: ${_params}${isInvalid}`, { code: 'INVALID_PARAMETER' });
+            }
+        }
+        else if (typeof _params === struct) {
+            if (struct === 'number') {
+                if (Math.abs(_params) > 4503599627370496) {
+                    throw `BREAK:INVALID_PARAMETER:"${_parentKey}" integer value should be within -4503599627370496 ~ +4503599627370546.`;
+                }
+            }
+            val = _params;
+        }
+        else {
+            throw new SkapiError(`Value: ${_params}${isInvalid}`, { code: 'INVALID_PARAMETER' });
+        }
+    }
+    else if (struct === null) {
+        val = _params;
+    }
+    if (val === undefined && errToThrow) {
+        throw errToThrow;
+    }
+    return val;
+}
+export default {
+    UserId,
+    PhoneNumber,
+    Birthdate,
+    Password,
+    Email,
+    Url,
+    specialChars,
+    Params
+};

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "skapi-js",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Javascript library for Skapi: Complete JAM Stack, front-end driven serverless backend API service.",
   "main": "./dist/skapi.module.js",
+  "types": "./js/Main.d.ts",
   "files": [
+    "js/",
     "dist/"
   ],
   "scripts": {
-    "build": "npx tsc --project tsconfig.esm.json; npx tsc --project tsconfig.json; npx webpack --config webpack.config.js",
+    "build": "npx tsc --project tsconfig.json; npx webpack --config webpack.config.js",
     "server": "(cd server; node server.js)"
   },
   "repository": {
@@ -33,6 +35,6 @@
     "jamstack"
   ],
   "dependencies": {
-    "amazon-cognito-identity-js": "^5.2.12"
+    "amazon-cognito-identity-js": "^5.2.14"
   }
 }