@ldmjs/ui 1.0.21 → 1.0.22

package/README.md

@@ -106,16 +106,36 @@ const vuetify = createVuetify({
  - ld-text-markup
  - ld-switch
  - ld-dialog
+ - ld-data-iterator
+ - ld-pager
 
 # Utilities
 
  - awaiting
- - isDefined
- - uidGen
+ - base64
+    .encode
+    .decode
+    .isValid
+ - cookie
+    .get
+    .set
+    .delete
  - delay
  - deepValueGetter
+ - isDefined
  - isObjectEmpty
- - datetime
+ - pluralizeNoun
+ - strings
+    .camelCase
+    .capitalize
+ - uidGen
+ - fileToArrayBuffer
+ - fileToBase64
+ - base64ToUint8Array
+ - Uint8ArrayToHex
+ - hexToArrayBuffer
+ - Uint8ArrayToBase64
+ - arrayBufferToUint8Array
 
 # Directives
  - v-active

package/dist/index.d.ts

@@ -18,7 +18,7 @@ import { Dialog } from './types/dialogs';
  */
 export declare function awaiting(callback: () => unknown): Promise<any>;
 /**
- * a = null (undefined, '', NaN) => isDefined(a) // false
+ * a = null (undefined, NaN) => isDefined(a) // false
  */
 export declare function isDefined(value: unknown): boolean;
 /**
@@ -44,24 +44,84 @@ export declare function deepValueGetter(obj: Record<string, unknown>, path: stri
  */
 export declare function isObjectEmpty(obj: Record<string, unknown>): boolean;
 
+/**
+ * @param num кол-во элементов
+ * @param one название в единичном варианте (1 элемент, 21 элемент и тд)
+ * @param two название в двоичном варианте (2 элемента, 3 элемента и тд)
+ * @param five название во множественном варианте (5 элементов, много элементов)
+ * @param printNum выводить ли кол-во
+ */
 export declare function pluralizeNoun(
   num: string | number,
   one: string,
   two: string,
   five: string,
-  printNum: boolean
+  printNum?: boolean
 ): string;
 
+/* convert File or Blob to ArrayBuffer */
+export declare function fileToArrayBuffer(value: File | Blob): Promise<ArrayBuffer>;
+/* convert File or Blob to Base64 */
+export declare function fileToBase64(value: File | Blob): Promise<string>;
+/* convert Base64 string to Uint8Array */
+export declare function base64ToUint8Array(base64: string): Uint8Array;
+/* convert Uint8Array to Hexadecimal system */
+export declare function Uint8ArrayToHex(bytes: Uint8Array): string;
+/* convert a hex string to an ArrayBuffer */
+export declare function hexToArrayBuffer(hex: string): Array<number>;
+/* convert Uint8Array to Base64 */
+export declare function Uint8ArrayToBase64(value: Uint8Array): string
+/* convert ArrayBuffer to Uint8Array */
+export declare function arrayBufferToUint8Array(value: ArrayBuffer): Uint8Array;
+
+export declare const cookie: {
+  get: (key: string) => string;
+  set: (key: string, value: string, expires?: string) => void;
+  delete: (key: string) => void;
+}
+
+export declare const base64: {
+  encode: (input: string) => string;
+  decode: (input: string) => string;
+  isValid: (input: string) => boolean;
+}
+
+export declare const strings: {
+  camelCase: (str: string) => string;
+  capitalize: (str: string) => string;
+}
+
 declare module '@vue/runtime-core' {
   export interface ComponentCustomProperties {
     $utils: {
-      awaiting: typeof awaiting;
-      isDefined: typeof isDefined;
-      uidGen: typeof uidGen;
-      delay: typeof delay;
-      deepValueGetter: typeof deepValueGetter;
-      isObjectEmpty: typeof isObjectEmpty;
-      pluralizeNoun: typeof pluralizeNoun;
+      awaiting: (callback: () => unknown) => Promise<any>;
+      base64: {
+        encode: (input: string) => string;
+        decode: (input: string) => string;
+        isValid: (input: string) => boolean;
+      }
+      cookie: {
+        get: (key: string) => string;
+        set: (key: string, value: string, expires?: string) => void;
+        delete: (key: string) => void;
+      }
+      isDefined: (value: unknown) => boolean;
+      delay: (timeout: number) => Promise<void>;
+      deepValueGetter: (obj: Record<string, unknown>, path: string) => unknown;
+      isObjectEmpty: (obj: Record<string, unknown>) => boolean;
+      pluralizeNoun: (num: string | number,one: string,two: string, five: string, printNum?: boolean) => string;
+      strings: {
+        camelCase: (str: string) => string;
+        capitalize: (str: string) => string;
+      }
+      uidGen: (len?: number, format?: string) => string | number;
+      fileToArrayBuffer: (value: File | Blob) => Promise<ArrayBuffer>;
+      fileToBase64: (value: File | Blob) => Promise<string>;
+      base64ToUint8Array: (base64: string) => Uint8Array;
+      Uint8ArrayToHex: (bytes: Uint8Array) => string;
+      hexToArrayBuffer: (hex: string) => Array<number>;
+      Uint8ArrayToBase64: (value: Uint8Array) => string;
+      arrayBufferToUint8Array: (value: ArrayBuffer) => Uint8Array;
     };
     $ldmui: {
       options: ldmuiOptions;

package/dist/index.js

@@ -250,18 +250,27 @@ __webpack_require__.d(__webpack_exports__, {
   ModalType: () => (/* reexport */ ModalType),
   PromptDialog: () => (/* reexport */ PromptDialog),
   SelectDialog: () => (/* reexport */ SelectDialog),
+  Uint8ArrayToHex: () => (/* reexport */ Uint8ArrayToHex),
   ValidateMixin: () => (/* reexport */ ValidateMixin),
   ValidateMixinOptions: () => (/* reexport */ ValidateMixinOptions),
   awaiting: () => (/* reexport */ awaiting),
+  base64: () => (/* reexport */ base64),
+  base64ToUint8Array: () => (/* reexport */ base64ToUint8Array),
+  cookie: () => (/* reexport */ cookie),
   deepValueGetter: () => (/* reexport */ deepValueGetter),
   "default": () => (/* binding */ src),
   defaults: () => (/* reexport */ defaults),
   delay: () => (/* reexport */ delay),
+  fileToArrayBuffer: () => (/* reexport */ fileToArrayBuffer),
+  fileToBase64: () => (/* reexport */ fileToBase64),
   getAliases: () => (/* reexport */ getAliases),
+  hexToArrayBuffer: () => (/* reexport */ hexToArrayBuffer),
   isDefined: () => (/* reexport */ isDefined),
   isObjectEmpty: () => (/* reexport */ isObjectEmpty),
   pluralizeNoun: () => (/* reexport */ pluralizeNoun),
+  strings: () => (/* reexport */ strings),
   uidGen: () => (/* reexport */ uidGen),
+  uint8ArrayToBase64: () => (/* reexport */ uint8ArrayToBase64),
   urlRegexp: () => (/* reexport */ urlRegexp)
 });
 
@@ -269,13 +278,22 @@ __webpack_require__.d(__webpack_exports__, {
 var src_utils_namespaceObject = {};
 __webpack_require__.r(src_utils_namespaceObject);
 __webpack_require__.d(src_utils_namespaceObject, {
+  Uint8ArrayToHex: () => (Uint8ArrayToHex),
   awaiting: () => (awaiting),
+  base64: () => (base64),
+  base64ToUint8Array: () => (base64ToUint8Array),
+  cookie: () => (cookie),
   deepValueGetter: () => (deepValueGetter),
   delay: () => (delay),
+  fileToArrayBuffer: () => (fileToArrayBuffer),
+  fileToBase64: () => (fileToBase64),
+  hexToArrayBuffer: () => (hexToArrayBuffer),
   isDefined: () => (isDefined),
   isObjectEmpty: () => (isObjectEmpty),
   pluralizeNoun: () => (pluralizeNoun),
+  strings: () => (strings),
   uidGen: () => (uidGen),
+  uint8ArrayToBase64: () => (uint8ArrayToBase64),
   urlRegexp: () => (urlRegexp)
 });
 
@@ -499,18 +517,6 @@ function isDefined(value) {
     return value !== null && value !== undefined && !isNaNValue;
 }
 
-;// CONCATENATED MODULE: ./src/utils/zIndex.ts
-function getZIndex(el) {
-    if (!el || el.nodeType !== Node.ELEMENT_NODE) {
-        return 0;
-    }
-    const index = Number(window.getComputedStyle(el).getPropertyValue('z-index'));
-    if (isNaN(index)) {
-        return getZIndex(el.parentNode);
-    }
-    return index;
-}
-
 ;// CONCATENATED MODULE: ./node_modules/ts-loader/index.js??clonedRuleSet-1.use!./src/ld-loader/ld-loader.ts?vue&type=script&lang=ts&external
 var ld_loadervue_type_script_lang_ts_external_decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -523,7 +529,6 @@ var ld_loadervue_type_script_lang_ts_external_metadata = (undefined && undefined
 };
 
 
-
 class LoaderComponent extends external_vue_property_decorator_.Vue {
     created() {
         if (!this.options.size) {
@@ -541,7 +546,7 @@ class LoaderComponent extends external_vue_property_decorator_.Vue {
     }
     get styles() {
         return {
-            'z-index': getZIndex(this.$parent.$el) + 2,
+            'z-index': this.zIndex(this.$parent.$el) + 2,
         };
     }
     get size() {
@@ -573,6 +578,16 @@ class LoaderComponent extends external_vue_property_decorator_.Vue {
         classes.push(`loader__color-${this.color}`);
         return classes;
     }
+    zIndex(el) {
+        if (!el || el.nodeType !== Node.ELEMENT_NODE) {
+            return 0;
+        }
+        const index = Number(window.getComputedStyle(el).getPropertyValue('z-index'));
+        if (isNaN(index)) {
+            return this.zIndex(el.parentNode);
+        }
+        return index;
+    }
 }
 ld_loadervue_type_script_lang_ts_external_decorate([
     (0,external_vue_property_decorator_.Prop)({ type: Object, default: { size: 'big', bg: true } }),
@@ -10027,9 +10042,9 @@ function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
 
 
 /** Built-in value references. */
-var Uint8Array = _root.Uint8Array;
+var _Uint8Array_Uint8Array = _root.Uint8Array;
 
-/* harmony default export */ const _Uint8Array = (Uint8Array);
+/* harmony default export */ const _Uint8Array = (_Uint8Array_Uint8Array);
 
 ;// CONCATENATED MODULE: ./node_modules/lodash-es/_mapToArray.js
 /**
@@ -15344,6 +15359,364 @@ function ld_dialogvue_type_template_id_184339ee_ts_true_render(_ctx, _cache, $pr
 
 // EXTERNAL MODULE: ./node_modules/@ldmjs/core/dist/index.js
 var dist = __webpack_require__(634);
+;// CONCATENATED MODULE: ./src/utils/awaiting.ts
+async function awaiting(callback) {
+    let resolveFunc = null;
+    const counter = 0;
+    let timer = null;
+    const promise = new Promise(resolve => {
+        resolveFunc = resolve;
+    });
+    timer = setInterval(() => {
+        const a = callback();
+        if (counter > 100 || Boolean(a)) {
+            clearInterval(timer);
+            resolveFunc(a ?? true);
+        }
+    }, 100);
+    await promise;
+}
+
+;// CONCATENATED MODULE: ./src/utils/base64.ts
+/* eslint-disable no-bitwise */
+class Base64Util {
+    constructor() {
+        this._keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+    }
+    encode(input) {
+        let output = '';
+        let chr1, chr2, chr3, enc1, enc2, enc3, enc4;
+        let i = 0;
+        input = Base64Util._utf8_encode(input);
+        while (i < input.length) {
+            chr1 = input.charCodeAt(i++);
+            chr2 = input.charCodeAt(i++);
+            chr3 = input.charCodeAt(i++);
+            enc1 = chr1 >> 2;
+            enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+            enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+            enc4 = chr3 & 63;
+            if (isNaN(chr2)) {
+                enc3 = enc4 = 64;
+            }
+            else if (isNaN(chr3)) {
+                enc4 = 64;
+            }
+            output =
+                output +
+                    this._keyStr.charAt(enc1) +
+                    this._keyStr.charAt(enc2) +
+                    this._keyStr.charAt(enc3) +
+                    this._keyStr.charAt(enc4);
+        }
+        return output;
+    }
+    decode(input) {
+        let output = '';
+        let chr1, chr2, chr3;
+        let enc1, enc2, enc3, enc4;
+        let i = 0;
+        input = input.replace(/[^\d+/=A-Za-z]/g, '');
+        while (i < input.length) {
+            enc1 = this._keyStr.indexOf(input.charAt(i++));
+            enc2 = this._keyStr.indexOf(input.charAt(i++));
+            enc3 = this._keyStr.indexOf(input.charAt(i++));
+            enc4 = this._keyStr.indexOf(input.charAt(i++));
+            chr1 = (enc1 << 2) | (enc2 >> 4);
+            chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+            chr3 = ((enc3 & 3) << 6) | enc4;
+            output = output + String.fromCharCode(chr1);
+            if (enc3 !== 64) {
+                output = output + String.fromCharCode(chr2);
+            }
+            if (enc4 !== 64) {
+                output = output + String.fromCharCode(chr3);
+            }
+        }
+        output = Base64Util._utf8_decode(output);
+        return output;
+    }
+    static _utf8_encode(str) {
+        str = str.replace(/\r\n/g, '\n');
+        let utftext = '';
+        for (let n = 0; n < str.length; n++) {
+            const c = str.charCodeAt(n);
+            if (c < 128) {
+                utftext += String.fromCharCode(c);
+            }
+            else if (c > 127 && c < 2048) {
+                utftext += String.fromCharCode((c >> 6) | 192);
+                utftext += String.fromCharCode((c & 63) | 128);
+            }
+            else {
+                utftext += String.fromCharCode((c >> 12) | 224);
+                utftext += String.fromCharCode(((c >> 6) & 63) | 128);
+                utftext += String.fromCharCode((c & 63) | 128);
+            }
+        }
+        return utftext;
+    }
+    static _utf8_decode(utftext) {
+        let string = '';
+        let i = 0;
+        let c = 0;
+        let c2 = 0;
+        let c3 = 0;
+        while (i < utftext.length) {
+            c = utftext.charCodeAt(i);
+            if (c < 128) {
+                string += String.fromCharCode(c);
+                i++;
+            }
+            else if (c > 191 && c < 224) {
+                c2 = utftext.charCodeAt(i + 1);
+                string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
+                i += 2;
+            }
+            else {
+                c2 = utftext.charCodeAt(i + 1);
+                c3 = utftext.charCodeAt(i + 2);
+                string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
+                i += 3;
+            }
+        }
+        return string;
+    }
+    isValid(value) {
+        // eslint-disable-next-line optimize-regex/optimize-regex
+        const base64Regex = /^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)?$/gim;
+        return base64Regex.test(value);
+    }
+}
+const base64 = new Base64Util();
+
+
+;// CONCATENATED MODULE: ./src/utils/cookie.ts
+class Cookie {
+    get(key) {
+        const _key = key.replace(/([$()*+./?[\\\]^{|}])/g, '\\$1');
+        const matches = document.cookie.match(new RegExp('(?:^|; )' + _key + '=([^;]*)'));
+        if (matches && matches[1] && matches[1].length) {
+            return matches[1];
+        }
+        return null;
+    }
+    set(key, value, expires) {
+        let time = 0;
+        switch (expires) {
+            case 'day':
+                time = 1000 * 60 * 60 * 24;
+                break;
+            case 'month':
+                time = 1000 * 60 * 60 * 24 * 30;
+                break;
+        }
+        let exp = '';
+        if (time) {
+            time = Date.now() + time;
+            exp = new Date(time).toUTCString();
+        }
+        document.cookie = key + '=' + value + '; path=/; expires=' + exp;
+    }
+    delete(key) {
+        document.cookie = key + '=; path=/; expires=-1';
+    }
+}
+const cookie = new Cookie();
+
+
+;// CONCATENATED MODULE: ./src/utils/converting.ts
+function fileToArrayBuffer(src) {
+    return new Promise(resolve => {
+        const reader = new FileReader();
+        reader.onloadend = function () {
+            resolve(reader.result);
+        };
+        reader.readAsArrayBuffer(src);
+    });
+}
+function fileToBase64(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.readAsDataURL(file);
+        reader.onload = () => {
+            let fileStr = reader.result.toString();
+            if (fileStr.includes(',')) {
+                fileStr = fileStr.split(',')[1];
+            }
+            resolve(fileStr);
+        };
+        reader.onerror = error => reject(error);
+    });
+}
+function base64ToUint8Array(base64) {
+    if (!base64.trim()) {
+        return null;
+    }
+    const decrypted = window.atob(base64);
+    let n = decrypted.length;
+    const arr = new Uint8Array(n);
+    while (n--) {
+        arr[n] = decrypted.charCodeAt(n);
+    }
+    return arr;
+}
+function Uint8ArrayToHex(bytes) {
+    const hex = [];
+    /* eslint-disable-next-line @typescript-eslint/prefer-for-of */
+    for (let i = 0; i < bytes.length; i++) {
+        const current = bytes[i] < 0 ? bytes[i] + 256 : bytes[i];
+        /* eslint-disable-next-line no-bitwise */
+        hex.push((current >>> 4).toString(16));
+        /* eslint-disable-next-line no-bitwise */
+        hex.push((current & 0xf).toString(16));
+    }
+    return hex.join('');
+}
+function hexToArrayBuffer(hex) {
+    hex = hex.replace(/^0x/, '');
+    if (hex.length % 2 != 0) {
+        // console.log('WARNING: expecting an even number of characters in the hexString');
+    }
+    const bad = hex.match(/[\sg-z]/i);
+    if (bad) {
+        // console.log('WARNING: found non-hex characters', bad);
+    }
+    const pairs = hex.match(/[\da-f]{2}/gi);
+    const result = [];
+    for (const s of pairs) {
+        result.push(parseInt(s, 16));
+    }
+    return result;
+}
+function uint8ArrayToBase64(value) {
+    const bin = value.reduce((acc, i) => (acc += String.fromCharCode.apply(null, [i])), '');
+    return window.btoa(bin);
+}
+function arrayBufferToUint8Array(value) {
+    return new Uint8Array(value);
+}
+
+
+;// CONCATENATED MODULE: ./src/utils/deepValueGetter.ts
+/**
+ * Returns a deep object given a string. zoo['animal.type']
+ * @param {object} obj
+ * @param {string} path
+ */
+function deepValueGetter(obj, path) {
+    if (obj === null) {
+        return '';
+    }
+    if (!obj || !path) {
+        return obj;
+    }
+    const value = obj[path];
+    // eslint-disable-next-line no-undefined
+    if (value !== undefined) {
+        return value;
+    }
+    let current = obj;
+    const split = path.split('.');
+    if (split.length) {
+        for (const key of split) {
+            current = current[key];
+            // if found undefined, return empty string
+            // eslint-disable-next-line no-undefined
+            if (current === undefined || current === null) {
+                return '';
+            }
+        }
+    }
+    return current;
+}
+
+;// CONCATENATED MODULE: ./src/utils/delay.ts
+async function delay(timeout) {
+    return new Promise(resolve => setTimeout(() => resolve(), timeout));
+}
+
+;// CONCATENATED MODULE: ./src/utils/isObjectEmpty.ts
+function isObjectEmpty(obj) {
+    for (const _i in obj) {
+        return false;
+    }
+    return true;
+}
+
+;// CONCATENATED MODULE: ./src/utils/pluralizeNoun.ts
+function pluralizeNoun(num, one, two, five, printNum = true) {
+    if (!num) {
+        return '';
+    }
+    let n;
+    if (typeof num === 'string') {
+        n = Number(num.match(/\d+\.?\d*/g));
+    }
+    else {
+        n = Math.abs(num);
+    }
+    n %= 100;
+    if (n >= 5 && n <= 20) {
+        return printNum ? `${num} ${five}` : `${five}`;
+    }
+    n %= 10;
+    if (n === 1) {
+        return printNum ? `${num} ${one}` : `${one}`;
+    }
+    if (n >= 2 && n <= 4) {
+        return printNum ? `${num} ${two}` : `${two}`;
+    }
+    return printNum ? `${num} ${five}` : `${five}`;
+}
+
+;// CONCATENATED MODULE: ./src/utils/strings.ts
+class Strings {
+    camelCase(str) {
+        // Replace special characters with a space
+        str = str.replace(/[^\d A-Za-z]/g, ' ');
+        // put a space before an uppercase letter
+        str = str.replace(/([a-z](?=[A-Z]))/g, '$1 ');
+        // Lower case first character and some other stuff
+        str = str
+            .replace(/([^\d A-Za-z])|^\d+/g, '')
+            .trim()
+            .toLowerCase();
+        // uppercase characters preceded by a space or number
+        str = str.replace(/([\d ]+)([A-Za-z])/g, (a, b, c) => b.trim() + c.toUpperCase());
+        return str;
+    }
+    capitalize(str) {
+        if (!str) {
+            return str;
+        }
+        const first = str[0];
+        const other = str.substring(1);
+        return `${first.toUpperCase()}${other}`;
+    }
+}
+const strings = new Strings();
+
+
+;// CONCATENATED MODULE: ./src/utils/urlRegexp.ts
+const urlRegexp = 
+// eslint-disable-next-line optimize-regex/optimize-regex
+/\b((?:[a-z][\w-]+:(?:\/{1,3}|[a-z0-9%])|www\d{0,3}[.]|[a-z0-9.\\-]+[.][a-z]{2,4}\/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\\[\]{};:'".,<>?«»“”‘’]))/i;
+
+;// CONCATENATED MODULE: ./src/utils/index.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
 ;// CONCATENATED MODULE: ./src/ld-dialog/dialog.manager.ts
 
 
@@ -16839,26 +17212,6 @@ IteratorItemComponent = IteratorItemComponent_1 = iteratorItem_decorate([
 ], IteratorItemComponent);
 /* harmony default export */ const iteratorItem = (IteratorItemComponent);
 
-;// CONCATENATED MODULE: ./src/utils/strings.ts
-function camelCase(str) {
-    // Replace special characters with a space
-    str = str.replace(/[^\d A-Za-z]/g, ' ');
-    // put a space before an uppercase letter
-    str = str.replace(/([a-z](?=[A-Z]))/g, '$1 ');
-    // Lower case first character and some other stuff
-    str = str
-        .replace(/([^\d A-Za-z])|^\d+/g, '')
-        .trim()
-        .toLowerCase();
-    // uppercase characters preceded by a space or number
-    str = str.replace(/([\d ]+)([A-Za-z])/g, (a, b, c) => b.trim() + c.toUpperCase());
-    return str;
-}
-const strings = {
-    camelCase
-};
-
-
 ;// CONCATENATED MODULE: ./src/ld-data-iterator/prefixes.ts
 /* eslint-disable no-undefined */
 
@@ -18196,32 +18549,6 @@ function ld_pagervue_type_template_id_03c82e7a_render(_ctx, _cache, $props, $set
 }
 ;// CONCATENATED MODULE: ./src/ld-pager/ld-pager.vue?vue&type=template&id=03c82e7a
 
-;// CONCATENATED MODULE: ./src/utils/pluralizeNoun.ts
-function pluralizeNoun(num, one, two, five, printNum = true) {
-    if (!num) {
-        return '';
-    }
-    let n;
-    if (typeof num === 'string') {
-        n = Number(num.match(/\d+\.?\d*/g));
-    }
-    else {
-        n = Math.abs(num);
-    }
-    n %= 100;
-    if (n >= 5 && n <= 20) {
-        return printNum ? `${num} ${five}` : `${five}`;
-    }
-    n %= 10;
-    if (n === 1) {
-        return printNum ? `${num} ${one}` : `${one}`;
-    }
-    if (n >= 2 && n <= 4) {
-        return printNum ? `${num} ${two}` : `${two}`;
-    }
-    return printNum ? `${num} ${five}` : `${five}`;
-}
-
 ;// CONCATENATED MODULE: ./node_modules/ts-loader/index.js??clonedRuleSet-1.use!./src/ld-pager/ld-pager.ts?vue&type=script&lang=js&external
 var ld_pagervue_type_script_lang_js_external_decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -18472,87 +18799,6 @@ function ld_pager_reg(vue, options) {
 // EXTERNAL MODULE: external "vue-toastification"
 var external_vue_toastification_ = __webpack_require__(7982);
 var external_vue_toastification_default = /*#__PURE__*/__webpack_require__.n(external_vue_toastification_);
-;// CONCATENATED MODULE: ./src/utils/awaiting.ts
-async function awaiting(callback) {
-    let resolveFunc = null;
-    const counter = 0;
-    let timer = null;
-    const promise = new Promise(resolve => {
-        resolveFunc = resolve;
-    });
-    timer = setInterval(() => {
-        const a = callback();
-        if (counter > 100 || Boolean(a)) {
-            clearInterval(timer);
-            resolveFunc(a ?? true);
-        }
-    }, 100);
-    await promise;
-}
-
-;// CONCATENATED MODULE: ./src/utils/deepValueGetter.ts
-/**
- * Returns a deep object given a string. zoo['animal.type']
- * @param {object} obj
- * @param {string} path
- */
-function deepValueGetter(obj, path) {
-    if (obj === null) {
-        return '';
-    }
-    if (!obj || !path) {
-        return obj;
-    }
-    // check if path matches a root-level field
-    // { "a.b.c": 123 }
-    const value = obj[path];
-    // eslint-disable-next-line no-undefined
-    if (value !== undefined) {
-        return value;
-    }
-    let current = obj;
-    const split = path.split('.');
-    if (split.length) {
-        for (const key of split) {
-            current = current[key];
-            // if found undefined, return empty string
-            // eslint-disable-next-line no-undefined
-            if (current === undefined || current === null) {
-                return '';
-            }
-        }
-    }
-    return current;
-}
-
-;// CONCATENATED MODULE: ./src/utils/delay.ts
-async function delay(timeout) {
-    return new Promise(resolve => setTimeout(() => resolve(), timeout));
-}
-
-;// CONCATENATED MODULE: ./src/utils/isObjectEmpty.ts
-function isObjectEmpty(obj) {
-    for (const _i in obj) {
-        return false;
-    }
-    return true;
-}
-
-;// CONCATENATED MODULE: ./src/utils/urlRegexp.ts
-const urlRegexp = 
-// eslint-disable-next-line optimize-regex/optimize-regex
-/\b((?:[a-z][\w-]+:(?:\/{1,3}|[a-z0-9%])|www\d{0,3}[.]|[a-z0-9.\\-]+[.][a-z]{2,4}\/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\\[\]{};:'".,<>?«»“”‘’]))/i;
-
-;// CONCATENATED MODULE: ./src/utils/index.ts
-
-
-
-
-
-
-
-
-
 ;// CONCATENATED MODULE: ./src/vuetify.ts
 const aliases = {
     SmallButton: 'VBtn',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ldmjs/ui",
-  "version": "1.0.21",
+  "version": "1.0.22",
   "description": "ldm ui",
   "main": "dist/index.js",
   "engines": {