tiny-essentials 1.0.0

package/dist/legacy/get/pagination.mjs

@@ -0,0 +1,91 @@
+import queryUrlJSON from './queryUrlJSON.mjs';
+/**
+ * Generates pagination metadata for a given query and current page.
+ * It builds a list of pages to display and determines whether "next" and "previous" buttons should be shown.
+ * The resulting object can be used to render a pagination UI.
+ *
+ * @param {string} query - The base query string to be appended to URLs (without `?` or `&`).
+ * @param {number} page - The current page number.
+ * @param {number} total - The total number of pages.
+ * @param {string} [url=''] - The base URL to which pagination parameters will be added.
+ * @param {string} [extraClass=''] - Additional class name for styling the pagination container.
+ * @param {string} [extraClass2=''] - Additional class name for individual page links.
+ *
+ * @returns {Object} Pagination metadata including:
+ *   - `url` {string} - The updated URL prefix to use for each page link.
+ *   - `extraClass` {string} - Additional class name passed through.
+ *   - `extraClass2` {string} - Additional class name passed through.
+ *   - `page` {number} - The current page.
+ *   - `pagination` {number[]} - An array of page numbers to be displayed.
+ *   - `previous` {boolean} - Whether there are previous pages.
+ *   - `next` {boolean} - Whether there are next pages.
+ *   - `firstPagination` {boolean} - `true` if page 1 is not in the visible pagination and should be shown separately.
+ *   - `lastPagination` {boolean} - `true` if the last page is not in the visible pagination and should be shown separately.
+ *   - `pages` {number} - Total number of pages.
+ */
+export default function pagination(query, page, total, url = '', extraClass = '', extraClass2 = '') {
+    // Fix URL
+    if (url) {
+        // Final URL Result
+        const finalURLResult = function (sqT = '') {
+            if (query)
+                return sqT + query + '&page=';
+            else
+                return 'page=';
+        };
+        // Param Fixed
+        const params = queryUrlJSON(url);
+        if (Object.keys(params).length > 0) {
+            if (params.page) {
+                url = url
+                    .replace(finalURLResult('&') + params.page, '')
+                    .replace('?' + query + '=' + params.page, '?')
+                    .replace('?&', '?');
+                if (Object.keys(params).length === 1)
+                    url += finalURLResult();
+                else
+                    url += finalURLResult('&');
+            }
+            else
+                url += finalURLResult('&');
+        }
+        else
+            url += finalURLResult('?');
+    }
+    // Pagination
+    const pagination = [];
+    const data = {
+        url: url,
+        extraClass: extraClass,
+        extraClass2: extraClass2,
+    };
+    data.next = false;
+    data.previous = false;
+    for (let i = page - 1; i > page - 5; i--) {
+        if (i > 0) {
+            pagination.push(i);
+            data.previous = true;
+        }
+    }
+    pagination.reverse();
+    pagination.push(page);
+    for (let i = page + 1; i < page + 5; i++) {
+        if (i <= total) {
+            pagination.push(i);
+            data.next = true;
+        }
+    }
+    // Build Data and send it
+    data.page = page;
+    data.pagination = pagination;
+    if (pagination.indexOf(1) < 0)
+        data.firstPagination = true;
+    else
+        data.firstPagination = false;
+    if (pagination.indexOf(total) < 0)
+        data.lastPagination = true;
+    else
+        data.lastPagination = false;
+    data.pages = total;
+    return data;
+}

package/dist/legacy/get/queryUrlByName.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+/**
+ * Extracts the value of a specific query parameter from a URL.
+ *
+ * - Supports parameter names with brackets (e.g. `arr[0]`).
+ * - Returns `null` if the parameter is not found.
+ * - Returns an empty string if the parameter exists without a value.
+ *
+ * Examples:
+ * ```js
+ * queryUrlByName('foo', 'http://example.com/?foo=bar'); // "bar"
+ * queryUrlByName('foo', 'http://example.com/?foo=');    // ""
+ * queryUrlByName('foo', 'http://example.com/');         // null
+ * queryUrlByName('arr[0]', 'http://x.com/?arr[0]=yes'); // "yes"
+ * ```
+ *
+ * @param {string} name - The name of the query parameter to retrieve.
+ * @param {string} url - The full URL from which to extract the parameter.
+ * @returns {string|null} The decoded value of the parameter, or `null` if not found.
+ */
+function queryUrlByName(name, url) {
+  let newName = name.replace(/[\[\]]/g, '\\$&');
+  var regex = new RegExp('[?&]' + newName + '(=([^&#]*)|&|#|$)'),
+    results = regex.exec(url);
+  if (!results) return null;
+  if (!results[2]) return '';
+  return decodeURIComponent(results[2].replace(/\+/g, ' '));
+}
+
+module.exports = queryUrlByName;

package/dist/legacy/get/queryUrlByName.d.mts

@@ -0,0 +1,20 @@
+/**
+ * Extracts the value of a specific query parameter from a URL.
+ *
+ * - Supports parameter names with brackets (e.g. `arr[0]`).
+ * - Returns `null` if the parameter is not found.
+ * - Returns an empty string if the parameter exists without a value.
+ *
+ * Examples:
+ * ```js
+ * queryUrlByName('foo', 'http://example.com/?foo=bar'); // "bar"
+ * queryUrlByName('foo', 'http://example.com/?foo=');    // ""
+ * queryUrlByName('foo', 'http://example.com/');         // null
+ * queryUrlByName('arr[0]', 'http://x.com/?arr[0]=yes'); // "yes"
+ * ```
+ *
+ * @param {string} name - The name of the query parameter to retrieve.
+ * @param {string} url - The full URL from which to extract the parameter.
+ * @returns {string|null} The decoded value of the parameter, or `null` if not found.
+ */
+export default function queryUrlByName(name: string, url: string): string | null;

package/dist/legacy/get/queryUrlByName.mjs

@@ -0,0 +1,28 @@
+/**
+ * Extracts the value of a specific query parameter from a URL.
+ *
+ * - Supports parameter names with brackets (e.g. `arr[0]`).
+ * - Returns `null` if the parameter is not found.
+ * - Returns an empty string if the parameter exists without a value.
+ *
+ * Examples:
+ * ```js
+ * queryUrlByName('foo', 'http://example.com/?foo=bar'); // "bar"
+ * queryUrlByName('foo', 'http://example.com/?foo=');    // ""
+ * queryUrlByName('foo', 'http://example.com/');         // null
+ * queryUrlByName('arr[0]', 'http://x.com/?arr[0]=yes'); // "yes"
+ * ```
+ *
+ * @param {string} name - The name of the query parameter to retrieve.
+ * @param {string} url - The full URL from which to extract the parameter.
+ * @returns {string|null} The decoded value of the parameter, or `null` if not found.
+ */
+export default function queryUrlByName(name, url) {
+    let newName = name.replace(/[\[\]]/g, '\\$&');
+    var regex = new RegExp('[?&]' + newName + '(=([^&#]*)|&|#|$)'), results = regex.exec(url);
+    if (!results)
+        return null;
+    if (!results[2])
+        return '';
+    return decodeURIComponent(results[2].replace(/\+/g, ' '));
+}

package/dist/legacy/get/queryUrlJSON.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+/**
+ * Parses the query string from a URL into a JSON object.
+ *
+ * - Supports `key=value` pairs.
+ * - Supports array syntax (`arr[]=1&arr[]=2`, or `arr[1]=x`).
+ * - Ignores fragments (`#`).
+ * - If no URL is passed, uses `window.location.href` by default.
+ *
+ * Examples:
+ * ```js
+ * queryUrlJSON('http://example.com/?name=John&colors[]=red&colors[]=blue');
+ * // => { name: 'John', colors: ['red', 'blue'] }
+ *
+ * queryUrlJSON('http://x.com/?arr[1]=a&arr[0]=b');
+ * // => { arr: ['b', 'a'] }
+ * ```
+ *
+ * @param {string} [url=location.href] - The full URL to parse.
+ * @returns {Object.<string, string|string[]>} A key-value object representing the parsed query.
+ */
+function queryUrlJSON(url) {
+  if (!url) url = location.href;
+  var question = url.indexOf('?');
+  var hash = url.indexOf('#');
+  if (hash === -1 && question === -1) return {};
+  if (hash === -1) hash = url.length;
+  var query =
+    question === -1 || hash === question + 1
+      ? url.substring(hash)
+      : url.substring(question + 1, hash);
+  var result = {};
+  query.split('&').forEach((part) => {
+    if (!part) return;
+    part = part.split('+').join(' '); // replace every + with space, regexp-free version
+    var eq = part.indexOf('=');
+    var key = eq > -1 ? part.substr(0, eq) : part;
+    var val = eq > -1 ? decodeURIComponent(part.substr(eq + 1)) : '';
+    var from = key.indexOf('[');
+    if (from === -1) result[decodeURIComponent(key)] = val;
+    else {
+      var to = key.indexOf(']', from);
+      var index = decodeURIComponent(key.substring(from + 1, to));
+      key = decodeURIComponent(key.substring(0, from));
+      if (!result[key]) result[key] = [];
+      if (!index) result[key].push(val);
+      else result[key][index] = val;
+    }
+  });
+  return result;
+}
+
+module.exports = queryUrlJSON;

package/dist/legacy/get/queryUrlJSON.d.mts

@@ -0,0 +1,23 @@
+/**
+ * Parses the query string from a URL into a JSON object.
+ *
+ * - Supports `key=value` pairs.
+ * - Supports array syntax (`arr[]=1&arr[]=2`, or `arr[1]=x`).
+ * - Ignores fragments (`#`).
+ * - If no URL is passed, uses `window.location.href` by default.
+ *
+ * Examples:
+ * ```js
+ * queryUrlJSON('http://example.com/?name=John&colors[]=red&colors[]=blue');
+ * // => { name: 'John', colors: ['red', 'blue'] }
+ *
+ * queryUrlJSON('http://x.com/?arr[1]=a&arr[0]=b');
+ * // => { arr: ['b', 'a'] }
+ * ```
+ *
+ * @param {string} [url=location.href] - The full URL to parse.
+ * @returns {Object.<string, string|string[]>} A key-value object representing the parsed query.
+ */
+export default function queryUrlJSON(url?: string): {
+    [x: string]: string | string[];
+};

package/dist/legacy/get/queryUrlJSON.mjs

@@ -0,0 +1,57 @@
+/**
+ * Parses the query string from a URL into a JSON object.
+ *
+ * - Supports `key=value` pairs.
+ * - Supports array syntax (`arr[]=1&arr[]=2`, or `arr[1]=x`).
+ * - Ignores fragments (`#`).
+ * - If no URL is passed, uses `window.location.href` by default.
+ *
+ * Examples:
+ * ```js
+ * queryUrlJSON('http://example.com/?name=John&colors[]=red&colors[]=blue');
+ * // => { name: 'John', colors: ['red', 'blue'] }
+ *
+ * queryUrlJSON('http://x.com/?arr[1]=a&arr[0]=b');
+ * // => { arr: ['b', 'a'] }
+ * ```
+ *
+ * @param {string} [url=location.href] - The full URL to parse.
+ * @returns {Object.<string, string|string[]>} A key-value object representing the parsed query.
+ */
+export default function queryUrlJSON(url) {
+    if (!url)
+        url = location.href;
+    var question = url.indexOf('?');
+    var hash = url.indexOf('#');
+    if (hash === -1 && question === -1)
+        return {};
+    if (hash === -1)
+        hash = url.length;
+    var query = question === -1 || hash === question + 1
+        ? url.substring(hash)
+        : url.substring(question + 1, hash);
+    var result = {};
+    query.split('&').forEach((part) => {
+        if (!part)
+            return;
+        part = part.split('+').join(' '); // replace every + with space, regexp-free version
+        var eq = part.indexOf('=');
+        var key = eq > -1 ? part.substr(0, eq) : part;
+        var val = eq > -1 ? decodeURIComponent(part.substr(eq + 1)) : '';
+        var from = key.indexOf('[');
+        if (from === -1)
+            result[decodeURIComponent(key)] = val;
+        else {
+            var to = key.indexOf(']', from);
+            var index = decodeURIComponent(key.substring(from + 1, to));
+            key = decodeURIComponent(key.substring(0, from));
+            if (!result[key])
+                result[key] = [];
+            if (!index)
+                result[key].push(val);
+            else
+                result[key][index] = val;
+        }
+    });
+    return result;
+}

package/dist/legacy/get/super_string_filter.cjs

@@ -0,0 +1,97 @@
+'use strict';
+
+var objType = require('./objType.cjs');
+
+/**
+ * Filters a list of strings by comparing each item against a list of validators.
+ *
+ * Each validator can be either:
+ * - A **string** (for exact match)
+ * - An **object** with one or more of the following:
+ *   - `starts`: {string} - The string must start with this prefix.
+ *   - `ends`: {string} - The string must end with this suffix.
+ *   - `regexp`: {RegExp} - The string must match the regular expression.
+ *
+ * The comparison stops at the first matching validator per item.
+ *
+ * Examples:
+ * ```js
+ * super_string_filter(['apple', 'banana', 'blueberry'], ['banana']); // ['banana']
+ * super_string_filter(['apple', 'banana'], [{ starts: 'app' }]); // ['apple']
+ * super_string_filter(['test.js'], [{ ends: '.js' }]); // ['test.js']
+ * super_string_filter(['data123'], [{ regexp: /^\w+\d+$/ }]); // ['data123']
+ * ```
+ *
+ * @param {string[]} list - The list of strings to filter.
+ * @param {(string|Object)[]} validator_list - The list of validators.
+ * @returns {string[]} A filtered array of strings that passed at least one validator.
+ */
+function super_string_filter(list, validator_list) {
+  // Result
+  const result = [];
+
+  // The For
+  for (const item in list) {
+    for (const item2 in validator_list) {
+      // Check Types
+
+      // String
+      if (typeof validator_list[item2] === 'string') {
+        if (list[item] === validator_list[item2]) {
+          result.push(validator_list[item2]);
+          break;
+        }
+      }
+
+      // Object
+      else if (objType(validator_list[item2], 'object')) {
+        // Validator
+        const tiny_validator = {};
+
+        // Starts With
+        tiny_validator.starts = {};
+        tiny_validator.starts.enabled = typeof validator_list[item2].starts === 'string';
+        if (tiny_validator.starts.enabled) {
+          tiny_validator.starts.result = list[item].startsWith(validator_list[item2].starts);
+        }
+
+        // Ends With
+        tiny_validator.ends = {};
+        tiny_validator.ends.enabled = typeof validator_list[item2].ends === 'string';
+        if (tiny_validator.ends.enabled) {
+          tiny_validator.ends.result = list[item].endsWith(validator_list[item2].ends);
+        }
+
+        // RegExp
+        tiny_validator.regexp = {};
+        tiny_validator.regexp.enabled = objType(validator_list[item2].regexp, 'regexp');
+        if (tiny_validator.regexp.enabled) {
+          tiny_validator.regexp.result = list[item].match(validator_list[item2].regexp);
+        }
+
+        // Check Validator
+        let allowed_timezone = true;
+        for (const item3 in tiny_validator) {
+          if (tiny_validator[item3].enabled) {
+            // Invalid Result
+            if (!tiny_validator[item3].result) {
+              allowed_timezone = false;
+              break;
+            }
+          }
+        }
+
+        // Start With
+        if (allowed_timezone) {
+          result.push(list[item]);
+          break;
+        }
+      }
+    }
+  }
+
+  // Result
+  return result;
+}
+
+module.exports = super_string_filter;

package/dist/legacy/get/super_string_filter.d.mts

@@ -0,0 +1,25 @@
+/**
+ * Filters a list of strings by comparing each item against a list of validators.
+ *
+ * Each validator can be either:
+ * - A **string** (for exact match)
+ * - An **object** with one or more of the following:
+ *   - `starts`: {string} - The string must start with this prefix.
+ *   - `ends`: {string} - The string must end with this suffix.
+ *   - `regexp`: {RegExp} - The string must match the regular expression.
+ *
+ * The comparison stops at the first matching validator per item.
+ *
+ * Examples:
+ * ```js
+ * super_string_filter(['apple', 'banana', 'blueberry'], ['banana']); // ['banana']
+ * super_string_filter(['apple', 'banana'], [{ starts: 'app' }]); // ['apple']
+ * super_string_filter(['test.js'], [{ ends: '.js' }]); // ['test.js']
+ * super_string_filter(['data123'], [{ regexp: /^\w+\d+$/ }]); // ['data123']
+ * ```
+ *
+ * @param {string[]} list - The list of strings to filter.
+ * @param {(string|Object)[]} validator_list - The list of validators.
+ * @returns {string[]} A filtered array of strings that passed at least one validator.
+ */
+export default function super_string_filter(list: string[], validator_list: (string | Object)[]): string[];

package/dist/legacy/get/super_string_filter.mjs

@@ -0,0 +1,83 @@
+import objType from './objType.mjs';
+/**
+ * Filters a list of strings by comparing each item against a list of validators.
+ *
+ * Each validator can be either:
+ * - A **string** (for exact match)
+ * - An **object** with one or more of the following:
+ *   - `starts`: {string} - The string must start with this prefix.
+ *   - `ends`: {string} - The string must end with this suffix.
+ *   - `regexp`: {RegExp} - The string must match the regular expression.
+ *
+ * The comparison stops at the first matching validator per item.
+ *
+ * Examples:
+ * ```js
+ * super_string_filter(['apple', 'banana', 'blueberry'], ['banana']); // ['banana']
+ * super_string_filter(['apple', 'banana'], [{ starts: 'app' }]); // ['apple']
+ * super_string_filter(['test.js'], [{ ends: '.js' }]); // ['test.js']
+ * super_string_filter(['data123'], [{ regexp: /^\w+\d+$/ }]); // ['data123']
+ * ```
+ *
+ * @param {string[]} list - The list of strings to filter.
+ * @param {(string|Object)[]} validator_list - The list of validators.
+ * @returns {string[]} A filtered array of strings that passed at least one validator.
+ */
+export default function super_string_filter(list, validator_list) {
+    // Result
+    const result = [];
+    // The For
+    for (const item in list) {
+        for (const item2 in validator_list) {
+            // Check Types
+            // String
+            if (typeof validator_list[item2] === 'string') {
+                if (list[item] === validator_list[item2]) {
+                    result.push(validator_list[item2]);
+                    break;
+                }
+            }
+            // Object
+            else if (objType(validator_list[item2], 'object')) {
+                // Validator
+                const tiny_validator = {};
+                // Starts With
+                tiny_validator.starts = {};
+                tiny_validator.starts.enabled = typeof validator_list[item2].starts === 'string';
+                if (tiny_validator.starts.enabled) {
+                    tiny_validator.starts.result = list[item].startsWith(validator_list[item2].starts);
+                }
+                // Ends With
+                tiny_validator.ends = {};
+                tiny_validator.ends.enabled = typeof validator_list[item2].ends === 'string';
+                if (tiny_validator.ends.enabled) {
+                    tiny_validator.ends.result = list[item].endsWith(validator_list[item2].ends);
+                }
+                // RegExp
+                tiny_validator.regexp = {};
+                tiny_validator.regexp.enabled = objType(validator_list[item2].regexp, 'regexp');
+                if (tiny_validator.regexp.enabled) {
+                    tiny_validator.regexp.result = list[item].match(validator_list[item2].regexp);
+                }
+                // Check Validator
+                let allowed_timezone = true;
+                for (const item3 in tiny_validator) {
+                    if (tiny_validator[item3].enabled) {
+                        // Invalid Result
+                        if (!tiny_validator[item3].result) {
+                            allowed_timezone = false;
+                            break;
+                        }
+                    }
+                }
+                // Start With
+                if (allowed_timezone) {
+                    result.push(list[item]);
+                    break;
+                }
+            }
+        }
+    }
+    // Result
+    return result;
+}

package/dist/legacy/get/versionCheck.cjs

@@ -0,0 +1,49 @@
+'use strict';
+
+var latestVersion = require('latest-version');
+var compareVersions = require('compare-versions');
+var moment = require('moment');
+
+// Modules
+
+// Check Version
+const check_version = {
+  v: null,
+  t: null,
+};
+
+/**
+ * Checks if the package version is up-to-date by comparing it with the latest version available on npm.
+ * The version check is cached and updated every hour.
+ *
+ * @param {Object} pkg - The package information.
+ * @param {string} pkg.name - The name of the package.
+ * @param {string} pkg.version - The current version of the package.
+ *
+ * @returns {Promise<Object>} The result object containing:
+ *   - `needUpdate`: {boolean} - `true` if the current version is outdated, `false` otherwise.
+ *   - `now`: {string} - The current version of the package.
+ *   - `new`: {string} - The latest version of the package available on npm.
+ */
+async function versionCheck(pkg) {
+  // Time Now
+  const now = moment();
+
+  // Check Version
+  if (!check_version.t || now.diff(check_version.t, 'hours') > 0) {
+    check_version.t = now.add(1, 'hours');
+    check_version.v = await latestVersion(pkg.name);
+  }
+
+  // Insert Version
+  const result = { needUpdate: compareVersions.compare(pkg.version, check_version.v, '<') };
+
+  // Allowed Show Version
+  result.now = pkg.version;
+  result.new = check_version.v;
+
+  // Return
+  return result;
+}
+
+module.exports = versionCheck;

package/dist/legacy/get/versionCheck.d.mts

@@ -0,0 +1,17 @@
+/**
+ * Checks if the package version is up-to-date by comparing it with the latest version available on npm.
+ * The version check is cached and updated every hour.
+ *
+ * @param {Object} pkg - The package information.
+ * @param {string} pkg.name - The name of the package.
+ * @param {string} pkg.version - The current version of the package.
+ *
+ * @returns {Promise<Object>} The result object containing:
+ *   - `needUpdate`: {boolean} - `true` if the current version is outdated, `false` otherwise.
+ *   - `now`: {string} - The current version of the package.
+ *   - `new`: {string} - The latest version of the package available on npm.
+ */
+export default function versionCheck(pkg: {
+    name: string;
+    version: string;
+}): Promise<Object>;

package/dist/legacy/get/versionCheck.mjs

@@ -0,0 +1,38 @@
+// Modules
+import latestVersion from 'latest-version';
+import { compare } from 'compare-versions';
+import moment from 'moment';
+// Check Version
+const check_version = {
+    v: null,
+    t: null,
+};
+/**
+ * Checks if the package version is up-to-date by comparing it with the latest version available on npm.
+ * The version check is cached and updated every hour.
+ *
+ * @param {Object} pkg - The package information.
+ * @param {string} pkg.name - The name of the package.
+ * @param {string} pkg.version - The current version of the package.
+ *
+ * @returns {Promise<Object>} The result object containing:
+ *   - `needUpdate`: {boolean} - `true` if the current version is outdated, `false` otherwise.
+ *   - `now`: {string} - The current version of the package.
+ *   - `new`: {string} - The latest version of the package available on npm.
+ */
+export default async function versionCheck(pkg) {
+    // Time Now
+    const now = moment();
+    // Check Version
+    if (!check_version.t || now.diff(check_version.t, 'hours') > 0) {
+        check_version.t = now.add(1, 'hours');
+        check_version.v = await latestVersion(pkg.name);
+    }
+    // Insert Version
+    const result = { needUpdate: compare(pkg.version, check_version.v, '<') };
+    // Allowed Show Version
+    result.now = pkg.version;
+    result.new = check_version.v;
+    // Return
+    return result;
+}