sprintify-ui 0.10.65 → 0.10.67

package/src/utils/deepIncludes.ts

@@ -1,77 +1,77 @@
-export interface SearchOpts {
-    maxDepth?: number;          // stop descending after this depth
-    maxCharsPerItem?: number;   // stop scanning item after reading this many chars
-    maxArray?: number;          // cap how many array items to inspect per array
-    cache?: WeakMap<object, string>; // optional: lazy per-item cache of a “search blob”
-}
-
-/**
- * Recursively searches an item (object, array, primitive) for a case-insensitive match of the query string.
- * Limits can be set to avoid excessive CPU usage on large/deep items.
- * @param item The item to search within.
- * @param queryRaw The query string to search for.
- * @param opts Optional search options.
- */
-export function deepIncludes(item: any, queryRaw: string, opts: SearchOpts = {}): boolean {
-    const q = queryRaw.toLowerCase();
-    const {
-        maxDepth = 3,
-        maxCharsPerItem = 3000,
-        maxArray = 64,
-        cache,
-    } = opts;
-
-    let consumed = 0;
-    const seen = new WeakSet<object>();
-
-    const feed = (s: string): boolean => {
-        // consume without allocating new strings repeatedly
-        consumed += s.length;
-        return s.toLowerCase().includes(q) || consumed >= maxCharsPerItem;
-    };
-
-    const visit = (val: any, depth: number): boolean => {
-        if (val == null) return false;
-        if (consumed >= maxCharsPerItem) return false;
-
-        const t = typeof val;
-
-        if (t === 'string') return feed(val);
-        if (t === 'number' || t === 'boolean') return feed(String(val));
-        if (t === 'bigint') return feed(val.toString());
-        if (t === 'symbol' || t === 'function') return false;
-
-        // objects & arrays
-        if (t === 'object') {
-            if (seen.has(val)) return false;
-            seen.add(val);
-
-            // Optional lazy cache: build once per object identity
-            if (cache && cache.has(val)) {
-                return feed(cache.get(val)!); // already lowercased when stored? not necessary since feed lowercases
-            }
-
-            if (depth >= maxDepth) return false;
-
-            if (Array.isArray(val)) {
-                const len = Math.min(val.length, maxArray);
-                for (let i = 0; i < len; i++) {
-                    if (visit(val[i], depth + 1)) return true;
-                }
-                return false;
-            }
-
-            // plain object: iterate own enumerable keys only
-            for (const k in val) {
-                // match on key names too (often helpful if values are IDs)
-                if (feed(k)) return true;
-                if (visit(val[k], depth + 1)) return true;
-            }
-            return false;
-        }
-
-        return false;
-    };
-
-    return visit(item, 0);
+export interface SearchOpts {
+    maxDepth?: number;          // stop descending after this depth
+    maxCharsPerItem?: number;   // stop scanning item after reading this many chars
+    maxArray?: number;          // cap how many array items to inspect per array
+    cache?: WeakMap<object, string>; // optional: lazy per-item cache of a “search blob”
+}
+
+/**
+ * Recursively searches an item (object, array, primitive) for a case-insensitive match of the query string.
+ * Limits can be set to avoid excessive CPU usage on large/deep items.
+ * @param item The item to search within.
+ * @param queryRaw The query string to search for.
+ * @param opts Optional search options.
+ */
+export function deepIncludes(item: any, queryRaw: string, opts: SearchOpts = {}): boolean {
+    const q = queryRaw.toLowerCase();
+    const {
+        maxDepth = 3,
+        maxCharsPerItem = 3000,
+        maxArray = 64,
+        cache,
+    } = opts;
+
+    let consumed = 0;
+    const seen = new WeakSet<object>();
+
+    const feed = (s: string): boolean => {
+        // consume without allocating new strings repeatedly
+        consumed += s.length;
+        return s.toLowerCase().includes(q) || consumed >= maxCharsPerItem;
+    };
+
+    const visit = (val: any, depth: number): boolean => {
+        if (val == null) return false;
+        if (consumed >= maxCharsPerItem) return false;
+
+        const t = typeof val;
+
+        if (t === 'string') return feed(val);
+        if (t === 'number' || t === 'boolean') return feed(String(val));
+        if (t === 'bigint') return feed(val.toString());
+        if (t === 'symbol' || t === 'function') return false;
+
+        // objects & arrays
+        if (t === 'object') {
+            if (seen.has(val)) return false;
+            seen.add(val);
+
+            // Optional lazy cache: build once per object identity
+            if (cache && cache.has(val)) {
+                return feed(cache.get(val)!); // already lowercased when stored? not necessary since feed lowercases
+            }
+
+            if (depth >= maxDepth) return false;
+
+            if (Array.isArray(val)) {
+                const len = Math.min(val.length, maxArray);
+                for (let i = 0; i < len; i++) {
+                    if (visit(val[i], depth + 1)) return true;
+                }
+                return false;
+            }
+
+            // plain object: iterate own enumerable keys only
+            for (const k in val) {
+                // match on key names too (often helpful if values are IDs)
+                if (feed(k)) return true;
+                if (visit(val[k], depth + 1)) return true;
+            }
+            return false;
+        }
+
+        return false;
+    };
+
+    return visit(item, 0);
 }

package/src/utils/fileSizeFormat.ts

@@ -1,15 +1,15 @@
-import { t } from '@/i18n';
-
-export default function (size: number): string {
-  const i = Math.floor(Math.log(size) / Math.log(1024));
-
-  const units = [
-    t('sui.units.b'),
-    t('sui.units.kb'),
-    t('sui.units.mb'),
-    t('sui.units.gb'),
-    t('sui.units.tb'),
-  ];
-
-  return +(size / Math.pow(1024, i)).toFixed(2) * 1 + ' ' + units[i];
-}
+import { t } from '@/i18n';
+
+export default function (size: number): string {
+  const i = Math.floor(Math.log(size) / Math.log(1024));
+
+  const units = [
+    t('sui.units.b'),
+    t('sui.units.kb'),
+    t('sui.units.mb'),
+    t('sui.units.gb'),
+    t('sui.units.tb'),
+  ];
+
+  return +(size / Math.pow(1024, i)).toFixed(2) * 1 + ' ' + units[i];
+}

package/src/utils/fileValidations.ts

@@ -1,26 +1,26 @@
-export function maxSize(blob: Blob, maxSize: number): boolean {
-  if (blob.size > maxSize) {
-    return false;
-  }
-
-  return true;
-}
-
-export function validExtension(
-  blob: Blob | File,
-  extensions?: string[] | undefined
-): boolean {
-  let extension = blob.type.split('/').pop();
-
-  if (blob instanceof File) {
-    extension = blob.name.split('.').pop();
-  }
-
-  if (extension && extensions && extensions.length) {
-    if (!extensions.includes(extension)) {
-      return false;
-    }
-  }
-
-  return true;
-}
+export function maxSize(blob: Blob, maxSize: number): boolean {
+  if (blob.size > maxSize) {
+    return false;
+  }
+
+  return true;
+}
+
+export function validExtension(
+  blob: Blob | File,
+  extensions?: string[] | undefined
+): boolean {
+  let extension = blob.type.split('/').pop();
+
+  if (blob instanceof File) {
+    extension = blob.name.split('.').pop();
+  }
+
+  if (extension && extensions && extensions.length) {
+    if (!extensions.includes(extension)) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/utils/getApiData.ts

@@ -1,12 +1,12 @@
-import { Collection, PaginatedCollection, ResourceCollection } from "@/types";
-import { isArray } from "lodash";
-
-export function getItems(data: Collection | PaginatedCollection | ResourceCollection | null | undefined) {
-    if (!data) {
-        return [];
-    }
-    if (isArray(data)) {
-        return data;
-    }
-    return data.data;
+import { Collection, PaginatedCollection, ResourceCollection } from "@/types";
+import { isArray } from "lodash";
+
+export function getItems(data: Collection | PaginatedCollection | ResourceCollection | null | undefined) {
+    if (!data) {
+        return [];
+    }
+    if (isArray(data)) {
+        return data;
+    }
+    return data.data;
 }

package/src/utils/index.ts

@@ -1,18 +1,18 @@
-import toHumanList from './toHumanList';
-import fileSizeFormat from './fileSizeFormat';
-import resizeImageFromURI from './resizeImageFromURI';
-import { disableScroll, enableScroll } from './scrollPreventer';
-import { blobToBase64, validateBase64, base64ToBlob } from './blob';
-import { getColorConfig } from './colors';
-
-export {
-  toHumanList,
-  fileSizeFormat,
-  disableScroll,
-  enableScroll,
-  resizeImageFromURI,
-  blobToBase64,
-  validateBase64,
-  base64ToBlob,
-  getColorConfig,
-};
+import toHumanList from './toHumanList';
+import fileSizeFormat from './fileSizeFormat';
+import resizeImageFromURI from './resizeImageFromURI';
+import { disableScroll, enableScroll } from './scrollPreventer';
+import { blobToBase64, validateBase64, base64ToBlob } from './blob';
+import { getColorConfig } from './colors';
+
+export {
+  toHumanList,
+  fileSizeFormat,
+  disableScroll,
+  enableScroll,
+  resizeImageFromURI,
+  blobToBase64,
+  validateBase64,
+  base64ToBlob,
+  getColorConfig,
+};

package/src/utils/resizeImageFromURI.ts

@@ -1,118 +1,118 @@
-export default function resizeImageFromURI(
-  source: string,
-  height: number,
-  width: number
-): Promise<string> {
-  const img = new Image();
-  img.src = source;
-  img.crossOrigin = 'anonymous';
-
-  return new Promise((resolve, reject) => {
-    img.onload = () => {
-      // Check if the image require resize at all
-      if (img.height <= height && img.width <= width) {
-        resolve(source);
-        return;
-      }
-
-      // Make sure the width and height preserve the original aspect ratio and adjust if needed
-      if (img.height > img.width) {
-        width = Math.floor(height * (img.width / img.height));
-      } else {
-        height = Math.floor(width * (img.height / img.width));
-      }
-
-      const resizingCanvas: HTMLCanvasElement =
-        document.createElement('canvas');
-      const resizingCanvasContext = resizingCanvas.getContext('2d');
-
-      if (!resizingCanvasContext) {
-        reject('Could not acquire context 2d');
-        return;
-      }
-
-      // Start with original image size
-      resizingCanvas.width = img.width;
-      resizingCanvas.height = img.height;
-
-      // Draw the original image on the (temp) resizing canvas
-      resizingCanvasContext.drawImage(
-        img,
-        0,
-        0,
-        resizingCanvas.width,
-        resizingCanvas.height
-      );
-
-      const curImageDimensions = {
-        width: Math.floor(img.width),
-        height: Math.floor(img.height),
-      };
-
-      const halfImageDimensions = {
-        width: null as number | null,
-        height: null as number | null,
-      };
-
-      // Quickly reduce the size by 50% each time in few iterations until the size is less then
-      // 2x time the target size - the motivation for it, is to reduce the aliasing that would have been
-      // created with direct reduction of very big image to small image
-      while (curImageDimensions.width * 0.5 > width) {
-        // Reduce the resizing canvas by half and refresh the image
-        halfImageDimensions.width = Math.floor(curImageDimensions.width * 0.5);
-        halfImageDimensions.height = Math.floor(
-          curImageDimensions.height * 0.5
-        );
-
-        resizingCanvasContext.drawImage(
-          resizingCanvas,
-          0,
-          0,
-          curImageDimensions.width,
-          curImageDimensions.height,
-          0,
-          0,
-          halfImageDimensions.width,
-          halfImageDimensions.height
-        );
-
-        curImageDimensions.width = halfImageDimensions.width;
-        curImageDimensions.height = halfImageDimensions.height;
-      }
-
-      // Now do final resize for the resizingCanvas to meet the dimension requirements
-      // directly to the output canvas, that will output the final image
-      const outputCanvas: HTMLCanvasElement = document.createElement('canvas');
-      const outputCanvasContext = outputCanvas.getContext('2d');
-
-      outputCanvas.width = width;
-      outputCanvas.height = height;
-
-      if (!outputCanvasContext) {
-        reject('Could not acquire context 2d');
-        return;
-      }
-
-      outputCanvasContext.drawImage(
-        resizingCanvas,
-        0,
-        0,
-        curImageDimensions.width,
-        curImageDimensions.height,
-        0,
-        0,
-        width,
-        height
-      );
-
-      // output the canvas pixels as an image. params: format, quality
-      const base64ResizedImage = outputCanvas.toDataURL('image/jpeg', 0.85);
-
-      // Cleanup
-      resizingCanvas.remove();
-      outputCanvas.remove();
-
-      resolve(base64ResizedImage);
-    };
-  });
-}
+export default function resizeImageFromURI(
+  source: string,
+  height: number,
+  width: number
+): Promise<string> {
+  const img = new Image();
+  img.src = source;
+  img.crossOrigin = 'anonymous';
+
+  return new Promise((resolve, reject) => {
+    img.onload = () => {
+      // Check if the image require resize at all
+      if (img.height <= height && img.width <= width) {
+        resolve(source);
+        return;
+      }
+
+      // Make sure the width and height preserve the original aspect ratio and adjust if needed
+      if (img.height > img.width) {
+        width = Math.floor(height * (img.width / img.height));
+      } else {
+        height = Math.floor(width * (img.height / img.width));
+      }
+
+      const resizingCanvas: HTMLCanvasElement =
+        document.createElement('canvas');
+      const resizingCanvasContext = resizingCanvas.getContext('2d');
+
+      if (!resizingCanvasContext) {
+        reject('Could not acquire context 2d');
+        return;
+      }
+
+      // Start with original image size
+      resizingCanvas.width = img.width;
+      resizingCanvas.height = img.height;
+
+      // Draw the original image on the (temp) resizing canvas
+      resizingCanvasContext.drawImage(
+        img,
+        0,
+        0,
+        resizingCanvas.width,
+        resizingCanvas.height
+      );
+
+      const curImageDimensions = {
+        width: Math.floor(img.width),
+        height: Math.floor(img.height),
+      };
+
+      const halfImageDimensions = {
+        width: null as number | null,
+        height: null as number | null,
+      };
+
+      // Quickly reduce the size by 50% each time in few iterations until the size is less then
+      // 2x time the target size - the motivation for it, is to reduce the aliasing that would have been
+      // created with direct reduction of very big image to small image
+      while (curImageDimensions.width * 0.5 > width) {
+        // Reduce the resizing canvas by half and refresh the image
+        halfImageDimensions.width = Math.floor(curImageDimensions.width * 0.5);
+        halfImageDimensions.height = Math.floor(
+          curImageDimensions.height * 0.5
+        );
+
+        resizingCanvasContext.drawImage(
+          resizingCanvas,
+          0,
+          0,
+          curImageDimensions.width,
+          curImageDimensions.height,
+          0,
+          0,
+          halfImageDimensions.width,
+          halfImageDimensions.height
+        );
+
+        curImageDimensions.width = halfImageDimensions.width;
+        curImageDimensions.height = halfImageDimensions.height;
+      }
+
+      // Now do final resize for the resizingCanvas to meet the dimension requirements
+      // directly to the output canvas, that will output the final image
+      const outputCanvas: HTMLCanvasElement = document.createElement('canvas');
+      const outputCanvasContext = outputCanvas.getContext('2d');
+
+      outputCanvas.width = width;
+      outputCanvas.height = height;
+
+      if (!outputCanvasContext) {
+        reject('Could not acquire context 2d');
+        return;
+      }
+
+      outputCanvasContext.drawImage(
+        resizingCanvas,
+        0,
+        0,
+        curImageDimensions.width,
+        curImageDimensions.height,
+        0,
+        0,
+        width,
+        height
+      );
+
+      // output the canvas pixels as an image. params: format, quality
+      const base64ResizedImage = outputCanvas.toDataURL('image/jpeg', 0.85);
+
+      // Cleanup
+      resizingCanvas.remove();
+      outputCanvas.remove();
+
+      resolve(base64ResizedImage);
+    };
+  });
+}

package/src/utils/scrollPreventer.ts

@@ -1,11 +1,11 @@
-import { disablePageScroll, enablePageScroll } from 'scroll-lock';
-
-function disableScroll() {
-  disablePageScroll();
-}
-
-function enableScroll() {
-  enablePageScroll();
-}
-
-export { disableScroll, enableScroll };
+import { disablePageScroll, enablePageScroll } from 'scroll-lock';
+
+function disableScroll() {
+  disablePageScroll();
+}
+
+function enableScroll() {
+  enablePageScroll();
+}
+
+export { disableScroll, enableScroll };

package/src/utils/sizeBehaviors.ts

@@ -1,4 +1,4 @@
-export enum SizeBehavior {
-    default = 'default',
-    input = 'input',
+export enum SizeBehavior {
+    default = 'default',
+    input = 'input',
 }

package/src/utils/sizes.ts

@@ -1,38 +1,38 @@
-const sizes = {
-    xs: {
-        fontSize: 'text-xs',
-        height: 'h-control-xs',
-        iconSize: 'h-[0.9rem] w-[0.9rem]',
-        buttonClass: 'btn-xs',
-    },
-    sm: {
-        fontSize: 'text-sm',
-        height: 'h-control-sm',
-        iconSize: 'h-[1.125rem] w-[1.125rem]',
-        buttonClass: 'btn-sm',
-    },
-    md: {
-        fontSize: 'text-base',
-        height: 'h-control-md',
-        iconSize: 'h-5 w-5',
-        buttonClass: 'btn-md',
-    },
-    lg: {
-        fontSize: 'text-lg',
-        height: 'h-control-lg',
-        iconSize: 'h-6 w-6',
-        buttonClass: 'btn-lg',
-    },
-    xl: {
-        fontSize: 'text-xl',
-        height: 'h-control-xl',
-        iconSize: 'h-7 w-7',
-        buttonClass: 'btn-xl',
-    }
-};
-
-type Size = keyof typeof sizes;
-
-export { sizes };
-
-export type { Size };
+const sizes = {
+    xs: {
+        fontSize: 'text-xs',
+        height: 'h-control-xs',
+        iconSize: 'h-[0.9rem] w-[0.9rem]',
+        buttonClass: 'btn-xs',
+    },
+    sm: {
+        fontSize: 'text-sm',
+        height: 'h-control-sm',
+        iconSize: 'h-[1.125rem] w-[1.125rem]',
+        buttonClass: 'btn-sm',
+    },
+    md: {
+        fontSize: 'text-base',
+        height: 'h-control-md',
+        iconSize: 'h-5 w-5',
+        buttonClass: 'btn-md',
+    },
+    lg: {
+        fontSize: 'text-lg',
+        height: 'h-control-lg',
+        iconSize: 'h-6 w-6',
+        buttonClass: 'btn-lg',
+    },
+    xl: {
+        fontSize: 'text-xl',
+        height: 'h-control-xl',
+        iconSize: 'h-7 w-7',
+        buttonClass: 'btn-xl',
+    }
+};
+
+type Size = keyof typeof sizes;
+
+export { sizes };
+
+export type { Size };

package/src/utils/slots.ts

@@ -1,13 +1,13 @@
-import { Comment } from 'vue';
-
-export function isSlotEmpty(slot: any, props = {}) {
-    return isVNodeEmpty(slot?.(props))
-}
-
-function isVNodeEmpty(vnode: any) {
-    return !vnode || asArray(vnode).every((vnode) => vnode.type === Comment)
-}
-
-function asArray(arg: any) {
-    return Array.isArray(arg) ? arg : arg != null ? [arg] : []
+import { Comment } from 'vue';
+
+export function isSlotEmpty(slot: any, props = {}) {
+    return isVNodeEmpty(slot?.(props))
+}
+
+function isVNodeEmpty(vnode: any) {
+    return !vnode || asArray(vnode).every((vnode) => vnode.type === Comment)
+}
+
+function asArray(arg: any) {
+    return Array.isArray(arg) ? arg : arg != null ? [arg] : []
 }