@itguy614/clean-ui 1.0.0 → 1.1.0

package/dist/utils/devWarn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devWarn.d.ts","sourceRoot":"","sources":["../../src/utils/devWarn.ts"],"names":[],"mappings":"AAWA,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAI9C;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,EAClE,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,IAAI,CAmBN"}

package/dist/utils/devWarn.js

@@ -0,0 +1,21 @@
+import { isColorRole as i } from "./color.js";
+const s = "primary, secondary, success, error, warning, info, surface, surface-light, surface-dark", l = /* @__PURE__ */ new Set();
+function c(o) {
+  l.has(o) || (l.add(o), console.warn(o));
+}
+function d(o, e, r) {
+  const n = e.value;
+  if (n != null && !e.allowed.includes(n)) {
+    const a = i(n) ? ` "${n}" is a color role — did you mean color="${n}"?` : "";
+    c(
+      `[clean-ui] ${o}: variant="${n}" is not valid. Expected one of: ${e.allowed.join(", ")}.${a}`
+    );
+  }
+  r != null && !i(r) && c(
+    `[clean-ui] ${o}: color="${r}" is not a valid role. Expected one of: ${s}.${r === "danger" ? ' Use color="error".' : ""}`
+  );
+}
+export {
+  c as warnOnce,
+  d as warnVariantColor
+};

package/dist/utils/scrollLock.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Body scroll lock for overlays.
+ *
+ * `overflow: hidden` on <body> is enough on desktop and Android, but iOS Safari
+ * ignores it for touch scrolling — the page keeps panning behind an open modal.
+ * The reliable fix there is pinning the body with `position: fixed` at its
+ * current offset and restoring the scroll position on unlock, which we apply
+ * only on iOS: it's more invasive (the document is briefly out of flow, and the
+ * scroll position round-trips through JS), so platforms that honor
+ * `overflow: hidden` shouldn't pay for it.
+ *
+ * Locks are reference-counted. Stacked overlays each lock and unlock, and the
+ * document is only restored — and the scroll offset only captured — at the
+ * outermost boundary.
+ */
+/** Lock body scrolling. Safe to call repeatedly — the lock is counted. */
+export declare function lockBodyScroll(): void;
+/** Release one lock. The document is restored when the last one is released. */
+export declare function unlockBodyScroll(): void;
+/** Whether a lock is currently held (exposed for tests). */
+export declare function isBodyScrollLocked(): boolean;
+//# sourceMappingURL=scrollLock.d.ts.map

package/dist/utils/scrollLock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrollLock.d.ts","sourceRoot":"","sources":["../../src/utils/scrollLock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAkCH,0EAA0E;AAC1E,wBAAgB,cAAc,IAAI,IAAI,CAuCrC;AAED,gFAAgF;AAChF,wBAAgB,gBAAgB,IAAI,IAAI,CA8BvC;AAED,4DAA4D;AAC5D,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C"}

package/dist/utils/scrollLock.js

@@ -0,0 +1,42 @@
+let n = 0, o = null;
+function r() {
+  if (typeof navigator > "u") return !1;
+  const t = navigator.userAgent;
+  return /iP(hone|ad|od)/.test(t) ? !0 : /Macintosh/.test(t) && (navigator.maxTouchPoints ?? 0) > 1;
+}
+function d() {
+  return window.innerWidth - document.documentElement.clientWidth;
+}
+function c() {
+  if (typeof document > "u" || (n += 1, n > 1)) return;
+  const t = document.body, i = r(), l = window.scrollY;
+  o = {
+    overflow: t.style.overflow,
+    position: t.style.position,
+    top: t.style.top,
+    left: t.style.left,
+    right: t.style.right,
+    width: t.style.width,
+    paddingRight: t.style.paddingRight,
+    scrollY: l,
+    pinned: i
+  };
+  const e = d();
+  if (e > 0) {
+    const s = parseFloat(getComputedStyle(t).paddingRight) || 0;
+    t.style.paddingRight = `${s + e}px`;
+  }
+  t.style.overflow = "hidden", i && (t.style.position = "fixed", t.style.top = `-${l}px`, t.style.left = "0", t.style.right = "0", t.style.width = "100%");
+}
+function u() {
+  if (typeof document > "u" || n === 0 || (n -= 1, n > 0 || !o)) return;
+  const t = document.body, { scrollY: i, pinned: l } = o;
+  if (t.style.overflow = o.overflow, t.style.position = o.position, t.style.top = o.top, t.style.left = o.left, t.style.right = o.right, t.style.width = o.width, t.style.paddingRight = o.paddingRight, o = null, l) {
+    const e = document.documentElement, s = e.style.scrollBehavior;
+    e.style.scrollBehavior = "auto", window.scrollTo(0, i), e.style.scrollBehavior = s;
+  }
+}
+export {
+  c as lockBodyScroll,
+  u as unlockBodyScroll
+};

package/dist/utils/storage.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Guarded Web Storage access.
+ *
+ * `localStorage` being *defined* doesn't mean it's usable: a sandboxed iframe
+ * without `allow-same-origin` throws on property access, Safari private mode and
+ * cookie-blocking settings can throw on read/write, and Node >= 22 exposes an
+ * inert global (no `getItem`) that jsdom-based test runners inherit. A
+ * `typeof window !== "undefined"` guard catches none of those.
+ *
+ * Route every read/write through here so a hostile storage environment
+ * degrades to "no persistence" instead of throwing — which matters most at
+ * module scope, where one throw takes the whole library barrel down.
+ */
+/** Read a key, or `null` if storage is unavailable or the read throws. */
+export declare function safeGetItem(key: string): string | null;
+/** Write a key. Returns whether it stuck — callers may ignore it. */
+export declare function safeSetItem(key: string, value: string): boolean;
+//# sourceMappingURL=storage.d.ts.map

package/dist/utils/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/utils/storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAcH,0EAA0E;AAC1E,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAMtD;AAED,qEAAqE;AACrE,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAU/D"}

package/dist/utils/storage.js

@@ -0,0 +1,27 @@
+function n() {
+  try {
+    return typeof localStorage > "u" || localStorage === null || typeof localStorage.getItem != "function" ? null : localStorage;
+  } catch {
+    return null;
+  }
+}
+function l(e) {
+  var t;
+  try {
+    return ((t = n()) == null ? void 0 : t.getItem(e)) ?? null;
+  } catch {
+    return null;
+  }
+}
+function u(e, t) {
+  try {
+    const r = n();
+    return r ? (r.setItem(e, t), !0) : !1;
+  } catch {
+    return !1;
+  }
+}
+export {
+  l as safeGetItem,
+  u as safeSetItem
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itguy614/clean-ui",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "type": "module",
   "description": "A clean, dark-mode-ready Vue 3 component library — 100+ token-driven, themeable, accessible components.",
   "license": "MIT",
@@ -35,6 +35,10 @@
       "import": "./dist/index.js"
     },
     "./styles": "./dist/clean-ui.css",
+    "./icons/lazy": {
+      "types": "./dist/icons/lazy.d.ts",
+      "import": "./dist/icons/lazy.js"
+    },
     "./*": "./dist/*"
   },
   "files": [
@@ -43,7 +47,8 @@
     "LICENSE"
   ],
   "sideEffects": [
-    "**/*.css"
+    "**/*.css",
+    "./dist/icons/lazy.js"
   ],
   "scripts": {
     "build": "vite build && vue-tsc --emitDeclarationOnly && node scripts/postbuild.mjs",