@versini/ui-utilities 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Arno Versini
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,170 @@
+# @versini/ui-utilities
+
+[![npm version](https://img.shields.io/npm/v/@versini/ui-utilities?style=flat-square)](https://www.npmjs.com/package/@versini/ui-utilities)
+![npm package minimized gzipped size](<https://img.shields.io/bundlejs/size/%40versini%2Fui-utilities?style=flat-square&label=size%20(gzip)>)
+
+> A collection of utility functions for device detection and performance optimization.
+
+This package provides lightweight utility functions commonly needed when building UI components, including device detection, viewport analysis, PWA mode detection, and function debouncing.
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Usage](#usage)
+- [API Reference](#api-reference)
+
+## Features
+
+- **📱 Device Detection**: Detect mobile devices, tablets, iPhones, and iPads
+- **🚀 PWA Support**: Detect if the app is running in standalone PWA mode
+- **⚡ Performance**: Debounce utility for optimizing expensive function calls
+- **🔧 TypeScript**: Fully typed with comprehensive type definitions
+- **🌲 Tree-shakeable**: Import only the utilities you need
+- **🪶 Lightweight**: Minimal footprint with no dependencies
+
+## Installation
+
+```bash
+npm install @versini/ui-utilities
+```
+
+## Usage
+
+```tsx
+import {
+  debounce,
+  isProbablyMobile,
+  isProbablyTablet,
+  isProbablyiPhone,
+  isProbablyiPad,
+  isPWAMode
+} from "@versini/ui-utilities";
+```
+
+## API Reference
+
+### debounce
+
+Creates a debounced function that delays invoking the provided function until after the specified wait time has elapsed since the last time the debounced function was invoked.
+
+```tsx
+const debouncedFn = debounce(func: (...args: any[]) => void, wait: number)
+```
+
+**Parameters:**
+
+- `func` - The function to debounce
+- `wait` - The number of milliseconds to delay
+
+**Returns:** A new debounced function
+
+**Example:**
+
+```tsx
+const handleResize = debounce(() => {
+  console.log("Window resized");
+}, 300);
+
+window.addEventListener("resize", handleResize);
+```
+
+---
+
+### isProbablyMobile
+
+Determines if the current viewport width suggests a mobile device. Uses a width threshold of 403 pixels.
+
+```tsx
+const isMobile = isProbablyMobile(): boolean
+```
+
+**Returns:** `true` if the viewport width is less than 403 pixels
+
+**Example:**
+
+```tsx
+if (isProbablyMobile()) {
+  // Render mobile-specific UI
+}
+```
+
+---
+
+### isProbablyTablet
+
+Determines if the current viewport width suggests a tablet device. Uses a width range between 403 and 1220 pixels.
+
+```tsx
+const isTablet = isProbablyTablet(): boolean
+```
+
+**Returns:** `true` if the viewport width is between 403 and 1220 pixels (inclusive)
+
+**Example:**
+
+```tsx
+if (isProbablyTablet()) {
+  // Render tablet-specific UI
+}
+```
+
+---
+
+### isProbablyiPhone
+
+Attempts to detect if the current device is likely an iPhone. Uses a combination of platform detection, user agent analysis, screen size, and touch capability checks.
+
+```tsx
+const isiPhone = isProbablyiPhone(): boolean
+```
+
+**Returns:** `true` if the device is likely an iPhone
+
+**Example:**
+
+```tsx
+if (isProbablyiPhone()) {
+  // Apply iPhone-specific behavior
+}
+```
+
+---
+
+### isProbablyiPad
+
+Attempts to detect if the current device is likely an iPad. Uses a combination of platform detection, user agent analysis, screen size, and touch capability checks.
+
+```tsx
+const isiPad = isProbablyiPad(): boolean
+```
+
+**Returns:** `true` if the device is likely an iPad
+
+**Example:**
+
+```tsx
+if (isProbablyiPad()) {
+  // Apply iPad-specific behavior
+}
+```
+
+---
+
+### isPWAMode
+
+Detects if the app is running in standalone/PWA mode. Checks for both the standard display-mode media query and the iOS-specific standalone property.
+
+```tsx
+const isPWA = isPWAMode(): boolean
+```
+
+**Returns:** `true` if the app is running as a standalone PWA
+
+**Example:**
+
+```tsx
+if (isPWAMode()) {
+  // Hide browser-specific UI elements
+}
+```

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Creates a debounced function that delays invoking the provided function until
+ * after the specified wait time has elapsed since the last time the debounced
+ * function was invoked.
+ *
+ * @param func - The function to debounce.
+ * @param wait - The number of milliseconds to delay.
+ * @returns A new debounced function.
+ *
+ */
+export declare const debounce: (func: (...args: any[]) => void, wait: number) => (...args: any[]) => void;
+
+/**
+ * Attempts to detect if the current device is likely an iPad. Uses a
+ * combination of platform detection, user agent analysis, screen size, and
+ * touch capability checks.
+ *
+ * @returns True if the device is likely an iPad.
+ *
+ */
+export declare const isProbablyiPad: () => boolean;
+
+/**
+ * Attempts to detect if the current device is likely an iPhone. Uses a
+ * combination of platform detection, user agent analysis, screen size, and
+ * touch capability checks.
+ *
+ * @returns True if the device is likely an iPhone.
+ *
+ */
+export declare const isProbablyiPhone: () => boolean;
+
+/**
+ * Determines if the current viewport width suggests a mobile device. Uses a
+ * width threshold of 403 pixels.
+ *
+ * @returns True if the viewport width is less than 403 pixels.
+ *
+ */
+export declare const isProbablyMobile: () => boolean;
+
+/**
+ * Determines if the current viewport width suggests a tablet device. Uses a
+ * width range between 403 and 1220 pixels.
+ *
+ * @returns True if the viewport width is between 403 and 1220 pixels (inclusive).
+ *
+ */
+export declare const isProbablyTablet: () => boolean;
+
+/**
+ * Detects if the app is running in standalone/PWA mode. Checks for both the
+ * standard display-mode media query and the iOS-specific standalone property.
+ *
+ * @returns True if the app is running as a standalone PWA.
+ *
+ */
+export declare const isPWAMode: () => boolean;
+
+export { }

package/dist/index.js

@@ -0,0 +1,97 @@
+/*!
+  @versini/ui-utilities v1.1.0
+  © 2025 gizmette.com
+*/
+try {
+  if (!window.__VERSINI_UI_UTILITIES__) {
+    window.__VERSINI_UI_UTILITIES__ = {
+      version: "1.1.0",
+      buildTime: "12/19/2025 03:10 PM EST",
+      homepage: "https://www.npmjs.com/package/@versini/ui-utilities",
+      license: "MIT",
+    };
+  }
+} catch (error) {
+  // nothing to declare officer
+}
+
+
+;// CONCATENATED MODULE: ./src/components/index.ts
+/**
+ * Creates a debounced function that delays invoking the provided function until
+ * after the specified wait time has elapsed since the last time the debounced
+ * function was invoked.
+ *
+ * @param func - The function to debounce.
+ * @param wait - The number of milliseconds to delay.
+ * @returns A new debounced function.
+ *
+ */ const debounce = (func, wait)=>{
+    let timeout;
+    return (...args)=>{
+        window.clearTimeout(timeout);
+        timeout = window.setTimeout(()=>func(...args), wait);
+    };
+};
+/**
+ * Determines if the current viewport width suggests a mobile device. Uses a
+ * width threshold of 403 pixels.
+ *
+ * @returns True if the viewport width is less than 403 pixels.
+ *
+ */ /* c8 ignore start */ const isProbablyMobile = ()=>{
+    return window.innerWidth < 403;
+};
+/* c8 ignore stop */ /**
+ * Determines if the current viewport width suggests a tablet device. Uses a
+ * width range between 403 and 1220 pixels.
+ *
+ * @returns True if the viewport width is between 403 and 1220 pixels (inclusive).
+ *
+ */ /* c8 ignore start */ const isProbablyTablet = ()=>{
+    return window.innerWidth >= 403 && window.innerWidth <= 1220;
+};
+/* c8 ignore stop */ /**
+ * Attempts to detect if the current device is likely an iPhone. Uses a
+ * combination of platform detection, user agent analysis, screen size, and
+ * touch capability checks.
+ *
+ * @returns True if the device is likely an iPhone.
+ *
+ */ /* c8 ignore start */ const isProbablyiPhone = ()=>{
+    const flagDevice = [
+        "iPhone Simulator",
+        "iPhone"
+    ].includes(navigator.platform) || navigator.userAgent.includes("Mac") && "ontouchend" in document || window.indexedDB !== null;
+    const flagUA = /iPhone/.test(navigator.userAgent);
+    const flagScreen = isProbablyMobile();
+    const flagIOS = navigator.maxTouchPoints > 1;
+    return flagDevice && flagUA && flagScreen && flagIOS;
+};
+/* c8 ignore stop */ /**
+ * Attempts to detect if the current device is likely an iPad. Uses a
+ * combination of platform detection, user agent analysis, screen size, and
+ * touch capability checks.
+ *
+ * @returns True if the device is likely an iPad.
+ *
+ */ /* c8 ignore start */ const isProbablyiPad = ()=>{
+    const flagDevice = [
+        "iPad Simulator",
+        "iPad"
+    ].includes(navigator.platform) || navigator.userAgent.includes("Mac") && "ontouchend" in document || window.indexedDB !== null;
+    const flagScreen = isProbablyTablet();
+    const flagIOS = navigator.maxTouchPoints > 1;
+    return flagDevice && flagScreen && flagIOS;
+};
+/* c8 ignore stop */ /**
+ * Detects if the app is running in standalone/PWA mode. Checks for both the
+ * standard display-mode media query and the iOS-specific standalone property.
+ *
+ * @returns True if the app is running as a standalone PWA.
+ *
+ */ /* c8 ignore start */ const isPWAMode = ()=>{
+    return window.matchMedia("(display-mode: standalone)").matches || window.navigator.standalone === true;
+}; /* c8 ignore stop */ 
+
+export { debounce, isPWAMode, isProbablyMobile, isProbablyTablet, isProbablyiPad, isProbablyiPhone };

package/package.json

@@ -0,0 +1,43 @@
+{
+	"name": "@versini/ui-utilities",
+	"version": "1.1.0",
+	"license": "MIT",
+	"author": "Arno Versini",
+	"publishConfig": {
+		"access": "public"
+	},
+	"homepage": "https://www.npmjs.com/package/@versini/ui-utilities",
+	"repository": {
+		"type": "git",
+		"url": "git@github.com:aversini/ui-components.git"
+	},
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"files": [
+		"dist",
+		"README.md"
+	],
+	"scripts": {
+		"build:check": "tsc",
+		"build:js": "rslib build",
+		"build:types": "echo 'Types now built with rslib'",
+		"build": "npm-run-all --serial clean build:check build:js",
+		"clean": "rimraf dist tmp",
+		"dev:js": "rslib build --watch",
+		"dev:types": "echo 'Types now watched with rslib'",
+		"dev": "rslib build --watch",
+		"lint": "biome lint src",
+		"lint:fix": "biome check src --write --no-errors-on-unmatched",
+		"prettier": "biome check --write --no-errors-on-unmatched",
+		"start": "static-server dist --port 5173",
+		"test:coverage:ui": "vitest --coverage --ui",
+		"test:coverage": "vitest run --coverage",
+		"test:watch": "vitest",
+		"test": "vitest run"
+	},
+	"sideEffects": [
+		"**/*.css"
+	],
+	"gitHead": "8c05a346766c79bba8ecbeb68c7adbb1e8c5e50c"
+}