@joewinke/jatui 0.1.31 → 0.2.0

package/dist/utils/mentionParser.js

@@ -8,9 +8,9 @@
  * routing via the `urlGenerator` parameter or by setting a default.
  */
 // Regex to match mention pattern: [@Display Name](type:id)
-const MENTION_REGEX = /\[@([^\]]+)\]\(([^:]+):([^)]+)\)/g;
+var MENTION_REGEX = /\[@([^\]]+)\]\(([^:]+):([^)]+)\)/g;
 // Default URL generator (apps can override)
-let defaultUrlGenerator = (type, id) => `#${type}/${id}`;
+var defaultUrlGenerator = function (type, id) { return "#".concat(type, "/").concat(id); };
 /**
  * Set the default URL generator for mentions.
  * Call this once at app startup to configure mention link routing.
@@ -22,20 +22,20 @@ export function setMentionUrlGenerator(generator) {
  * Parse message content and extract all mentions
  */
 export function parseMentions(content, urlGenerator) {
-    const mentions = [];
-    const gen = urlGenerator ?? defaultUrlGenerator;
-    let match;
+    var mentions = [];
+    var gen = urlGenerator !== null && urlGenerator !== void 0 ? urlGenerator : defaultUrlGenerator;
+    var match;
     MENTION_REGEX.lastIndex = 0;
     while ((match = MENTION_REGEX.exec(content)) !== null) {
-        const [fullMatch, displayName, type, id] = match;
+        var fullMatch = match[0], displayName = match[1], type = match[2], id = match[3];
         mentions.push({
-            type,
-            id,
-            displayName,
+            type: type,
+            id: id,
+            displayName: displayName,
             url: gen(type, id),
             startIndex: match.index,
             endIndex: match.index + fullMatch.length,
-            fullMatch
+            fullMatch: fullMatch
         });
     }
     return mentions;
@@ -44,15 +44,15 @@ export function parseMentions(content, urlGenerator) {
  * Convert message content with mentions to HTML
  */
 export function renderMentionsAsHTML(content, urlGenerator) {
-    const mentions = parseMentions(content, urlGenerator);
+    var mentions = parseMentions(content, urlGenerator);
     if (mentions.length === 0) {
         return escapeHTML(content);
     }
-    let result = '';
-    let lastIndex = 0;
-    mentions.forEach((mention) => {
+    var result = '';
+    var lastIndex = 0;
+    mentions.forEach(function (mention) {
         result += escapeHTML(content.substring(lastIndex, mention.startIndex));
-        result += `<a href="${mention.url}" class="mention-link mention-${mention.type}" data-mention-type="${mention.type}" data-mention-id="${mention.id}">@${escapeHTML(mention.displayName)}</a>`;
+        result += "<a href=\"".concat(mention.url, "\" class=\"mention-link mention-").concat(mention.type, "\" data-mention-type=\"").concat(mention.type, "\" data-mention-id=\"").concat(mention.id, "\">@").concat(escapeHTML(mention.displayName), "</a>");
         lastIndex = mention.endIndex;
     });
     result += escapeHTML(content.substring(lastIndex));
@@ -62,7 +62,7 @@ export function renderMentionsAsHTML(content, urlGenerator) {
  * Create a mention string for insertion into message input
  */
 export function createMentionString(type, id, displayName) {
-    return `[@${displayName}](${type}:${id})`;
+    return "[@".concat(displayName, "](").concat(type, ":").concat(id, ")");
 }
 /**
  * Extract plain text from message content (remove mention markup)
@@ -75,18 +75,18 @@ export function extractPlainText(content) {
  * Check if cursor is inside a mention
  */
 export function findMentionAtCursor(content, cursorPosition) {
-    const mentions = parseMentions(content);
-    return (mentions.find((mention) => cursorPosition >= mention.startIndex && cursorPosition <= mention.endIndex) || null);
+    var mentions = parseMentions(content);
+    return (mentions.find(function (mention) { return cursorPosition >= mention.startIndex && cursorPosition <= mention.endIndex; }) || null);
 }
 /**
  * Find @ symbol and following text that could be a mention being typed.
  * Supported symbols: @ $ # ! ~ / +
  */
 export function findPartialMention(content, cursorPosition) {
-    const mentionSymbols = ['@', '$', '#', '!', '~', '/', '+'];
-    let symbolIndex = -1;
-    for (let i = cursorPosition - 1; i >= 0; i--) {
-        const char = content[i];
+    var mentionSymbols = ['@', '$', '#', '!', '~', '/', '+'];
+    var symbolIndex = -1;
+    for (var i = cursorPosition - 1; i >= 0; i--) {
+        var char = content[i];
         if (mentionSymbols.includes(char)) {
             symbolIndex = i;
             break;
@@ -97,21 +97,21 @@ export function findPartialMention(content, cursorPosition) {
     }
     if (symbolIndex === -1)
         return null;
-    const query = content.substring(symbolIndex + 1, cursorPosition).trim();
-    const existingMention = findMentionAtCursor(content, symbolIndex);
+    var query = content.substring(symbolIndex + 1, cursorPosition).trim();
+    var existingMention = findMentionAtCursor(content, symbolIndex);
     if (existingMention)
         return null;
-    return { start: symbolIndex, query };
+    return { start: symbolIndex, query: query };
 }
 /**
  * Replace partial mention with complete mention string
  */
 export function replaceMentionInContent(content, startIndex, endIndex, mentionString) {
-    const before = content.substring(0, startIndex);
-    const after = content.substring(endIndex);
-    const newContent = before + mentionString + after;
-    const newCursorPosition = startIndex + mentionString.length;
-    return { newContent, newCursorPosition };
+    var before = content.substring(0, startIndex);
+    var after = content.substring(endIndex);
+    var newContent = before + mentionString + after;
+    var newCursorPosition = startIndex + mentionString.length;
+    return { newContent: newContent, newCursorPosition: newCursorPosition };
 }
 /**
  * Simple HTML escape function

package/dist/utils/phone.js

@@ -1,31 +1,34 @@
 import { parsePhoneNumberFromString, getCountries, getCountryCallingCode, } from "libphonenumber-js";
-export const DEFAULT_COUNTRY = "US";
-export function toE164(raw, defaultCountry = DEFAULT_COUNTRY) {
+export var DEFAULT_COUNTRY = "US";
+export function toE164(raw, defaultCountry) {
+    if (defaultCountry === void 0) { defaultCountry = DEFAULT_COUNTRY; }
     if (!raw)
         return null;
-    const trimmed = raw.trim();
+    var trimmed = raw.trim();
     if (!trimmed)
         return null;
-    const parsed = parsePhoneNumberFromString(trimmed, defaultCountry);
-    if (parsed?.isValid())
+    var parsed = parsePhoneNumberFromString(trimmed, defaultCountry);
+    if (parsed === null || parsed === void 0 ? void 0 : parsed.isValid())
         return parsed.number;
     return null;
 }
 export function formatPhoneForDisplay(e164) {
     if (!e164)
         return "";
-    const parsed = parsePhoneNumberFromString(e164);
+    var parsed = parsePhoneNumberFromString(e164);
     if (!parsed)
         return e164;
     return parsed.country === DEFAULT_COUNTRY ? parsed.formatNational() : parsed.formatInternational();
 }
-export function isValidPhone(raw, defaultCountry = DEFAULT_COUNTRY) {
+export function isValidPhone(raw, defaultCountry) {
+    var _a;
+    if (defaultCountry === void 0) { defaultCountry = DEFAULT_COUNTRY; }
     if (!raw)
         return false;
-    const parsed = parsePhoneNumberFromString(raw.trim(), defaultCountry);
-    return parsed?.isValid() ?? false;
+    var parsed = parsePhoneNumberFromString(raw.trim(), defaultCountry);
+    return (_a = parsed === null || parsed === void 0 ? void 0 : parsed.isValid()) !== null && _a !== void 0 ? _a : false;
 }
-const COUNTRY_NAMES = {
+var COUNTRY_NAMES = {
     US: "United States", CA: "Canada", GB: "United Kingdom", AU: "Australia", NZ: "New Zealand",
     IE: "Ireland", DE: "Germany", FR: "France", ES: "Spain", IT: "Italy", NL: "Netherlands",
     BE: "Belgium", CH: "Switzerland", AT: "Austria", SE: "Sweden", NO: "Norway", DK: "Denmark",
@@ -40,22 +43,25 @@ function flagEmoji(code) {
     return code
         .toUpperCase()
         .split("")
-        .map((c) => String.fromCodePoint(127397 + c.charCodeAt(0)))
+        .map(function (c) { return String.fromCodePoint(127397 + c.charCodeAt(0)); })
         .join("");
 }
-let countriesCache = null;
+var countriesCache = null;
 export function listCountries() {
     if (countriesCache)
         return countriesCache;
-    const all = getCountries()
-        .map((code) => ({
-        code,
-        name: COUNTRY_NAMES[code] ?? code,
-        dialCode: `+${getCountryCallingCode(code)}`,
-        flag: flagEmoji(code),
-    }))
-        .sort((a, b) => a.name.localeCompare(b.name));
+    var all = getCountries()
+        .map(function (code) {
+        var _a;
+        return ({
+            code: code,
+            name: (_a = COUNTRY_NAMES[code]) !== null && _a !== void 0 ? _a : code,
+            dialCode: "+".concat(getCountryCallingCode(code)),
+            flag: flagEmoji(code),
+        });
+    })
+        .sort(function (a, b) { return a.name.localeCompare(b.name); });
     countriesCache = all;
     return all;
 }
-export const PRIORITY_COUNTRIES = ["US", "CA", "GB", "AU", "MX"];
+export var PRIORITY_COUNTRIES = ["US", "CA", "GB", "AU", "MX"];

package/dist/utils/phoneFormat.js

@@ -14,19 +14,19 @@ export function stripPhoneNumber(value) {
  * Formats a phone number to (xxx) xxx-xxxx format
  */
 export function formatPhoneNumber(value) {
-    const digits = stripPhoneNumber(value);
-    const limitedDigits = digits.slice(0, 10);
+    var digits = stripPhoneNumber(value);
+    var limitedDigits = digits.slice(0, 10);
     if (limitedDigits.length === 0) {
         return '';
     }
     else if (limitedDigits.length <= 3) {
-        return `(${limitedDigits}`;
+        return "(".concat(limitedDigits);
     }
     else if (limitedDigits.length <= 6) {
-        return `(${limitedDigits.slice(0, 3)}) ${limitedDigits.slice(3)}`;
+        return "(".concat(limitedDigits.slice(0, 3), ") ").concat(limitedDigits.slice(3));
     }
     else {
-        return `(${limitedDigits.slice(0, 3)}) ${limitedDigits.slice(3, 6)}-${limitedDigits.slice(6)}`;
+        return "(".concat(limitedDigits.slice(0, 3), ") ").concat(limitedDigits.slice(3, 6), "-").concat(limitedDigits.slice(6));
     }
 }
 /**
@@ -45,11 +45,11 @@ export function isValidPhoneNumber(value) {
  * Handles input formatting with cursor position preservation
  */
 export function updatePhoneInput(input, newValue, oldValue) {
-    const cursorPosition = input.selectionStart || 0;
-    const oldLength = oldValue.length;
-    const newLength = newValue.length;
+    var cursorPosition = input.selectionStart || 0;
+    var oldLength = oldValue.length;
+    var newLength = newValue.length;
     input.value = newValue;
-    let newCursorPosition = cursorPosition;
+    var newCursorPosition = cursorPosition;
     if (newLength > oldLength) {
         newCursorPosition = cursorPosition + (newLength - oldLength);
     }

package/dist/utils/sound.d.ts

@@ -0,0 +1,6 @@
+export declare function isSoundEnabled(): boolean;
+export declare function setSoundEnabled(enabled: boolean): void;
+export declare function registerSound(name: string, dataUri: string): Promise<void>;
+export declare function play(name: string, options?: {
+    volume?: number;
+}): void;

package/dist/utils/sound.js

@@ -0,0 +1,113 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var ctx = null;
+var buffers = new Map();
+var STORAGE_KEY = 'jatui-sound-enabled';
+function getContext() {
+    if (ctx)
+        return ctx;
+    try {
+        ctx = new AudioContext();
+        return ctx;
+    }
+    catch (_a) {
+        return null;
+    }
+}
+export function isSoundEnabled() {
+    if (typeof localStorage === 'undefined')
+        return false;
+    return localStorage.getItem(STORAGE_KEY) === 'true';
+}
+export function setSoundEnabled(enabled) {
+    if (typeof localStorage === 'undefined')
+        return;
+    localStorage.setItem(STORAGE_KEY, String(enabled));
+}
+export function registerSound(name, dataUri) {
+    return __awaiter(this, void 0, Promise, function () {
+        var audioCtx, base64, binary, bytes, i, buffer, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    audioCtx = getContext();
+                    if (!audioCtx)
+                        return [2 /*return*/];
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    base64 = dataUri.split(',')[1];
+                    binary = atob(base64);
+                    bytes = new Uint8Array(binary.length);
+                    for (i = 0; i < binary.length; i++)
+                        bytes[i] = binary.charCodeAt(i);
+                    return [4 /*yield*/, audioCtx.decodeAudioData(bytes.buffer)];
+                case 2:
+                    buffer = _b.sent();
+                    buffers.set(name, buffer);
+                    return [3 /*break*/, 4];
+                case 3:
+                    _a = _b.sent();
+                    return [3 /*break*/, 4];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+export function play(name, options) {
+    var _a;
+    if (options === void 0) { options = {}; }
+    if (!isSoundEnabled())
+        return;
+    var audioCtx = getContext();
+    if (!audioCtx)
+        return;
+    var buffer = buffers.get(name);
+    if (!buffer)
+        return;
+    // Resume suspended context (browser autoplay policy requires user gesture first)
+    if (audioCtx.state === 'suspended') {
+        audioCtx.resume().catch(function () { });
+    }
+    var source = audioCtx.createBufferSource();
+    var gain = audioCtx.createGain();
+    gain.gain.value = (_a = options.volume) !== null && _a !== void 0 ? _a : 0.15;
+    source.buffer = buffer;
+    source.connect(gain);
+    gain.connect(audioCtx.destination);
+    source.start();
+}

package/dist/utils/splitText.d.ts

@@ -0,0 +1,25 @@
+export type SplitBy = 'char' | 'word' | 'line';
+export interface SplitTextOptions {
+    by: SplitBy;
+}
+export interface SplitTextResult {
+    /** Total number of split units (chars, words, or lines). */
+    count: number;
+    /** Call to restore original DOM content and remove data attributes. */
+    cleanup: () => void;
+}
+/**
+ * Wraps text content of `node` into `<span>` elements and stamps CSS custom
+ * properties so pure-CSS animations can stagger by index.
+ *
+ * For `by: 'char'`: sets `--char-index` (0-based) and `--char-total`.
+ * For `by: 'word'`: sets `--word-index` (0-based) and `--word-total`.
+ * For `by: 'line'`: sets `--line-index` (0-based) and `--line-total`.
+ *
+ * Accessibility: stamps `aria-label` with the original text on `node` and
+ * marks every injected span as `aria-hidden="true"`.
+ *
+ * Re-splitting a node that has already been split is safe — previous spans
+ * are flattened back to text before the new split.
+ */
+export declare function splitText(node: HTMLElement, options: SplitTextOptions): SplitTextResult;

package/dist/utils/splitText.js

@@ -0,0 +1,94 @@
+// Pattern after Splitting.js (MIT) — https://github.com/shshaw/Splitting
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+/**
+ * Wraps text content of `node` into `<span>` elements and stamps CSS custom
+ * properties so pure-CSS animations can stagger by index.
+ *
+ * For `by: 'char'`: sets `--char-index` (0-based) and `--char-total`.
+ * For `by: 'word'`: sets `--word-index` (0-based) and `--word-total`.
+ * For `by: 'line'`: sets `--line-index` (0-based) and `--line-total`.
+ *
+ * Accessibility: stamps `aria-label` with the original text on `node` and
+ * marks every injected span as `aria-hidden="true"`.
+ *
+ * Re-splitting a node that has already been split is safe — previous spans
+ * are flattened back to text before the new split.
+ */
+export function splitText(node, options) {
+    var _a, _b;
+    var by = options.by;
+    // Capture original text and restore any previous split.
+    var originalText = (_b = (_a = node.getAttribute('data-split-original')) !== null && _a !== void 0 ? _a : node.textContent) !== null && _b !== void 0 ? _b : '';
+    restoreNode(node, originalText);
+    // Set accessibility label so the unsplit text is announced.
+    node.setAttribute('aria-label', originalText);
+    node.setAttribute('data-split-original', originalText);
+    node.setAttribute('data-split-by', by);
+    var count = 0;
+    if (by === 'char') {
+        var chars = __spreadArray([], originalText, true); // Unicode-aware
+        count = chars.length;
+        node.innerHTML = '';
+        for (var i = 0; i < chars.length; i++) {
+            node.appendChild(makeSpan(chars[i], '--char-index', i, '--char-total', count));
+        }
+    }
+    else if (by === 'word') {
+        // Split preserving whitespace tokens so spaces render correctly.
+        var tokens = originalText.split(/(\s+)/);
+        var words = tokens.filter(function (t) { return !/^\s+$/.test(t); });
+        count = words.length;
+        node.innerHTML = '';
+        var wordIdx = 0;
+        for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
+            var token = tokens_1[_i];
+            if (/^\s+$/.test(token)) {
+                var space = document.createElement('span');
+                space.setAttribute('aria-hidden', 'true');
+                space.style.whiteSpace = 'pre';
+                space.textContent = token;
+                node.appendChild(space);
+            }
+            else {
+                node.appendChild(makeSpan(token, '--word-index', wordIdx++, '--word-total', count));
+            }
+        }
+    }
+    else {
+        // 'line' — split by newline characters in the original text.
+        var lines = originalText.split('\n');
+        count = lines.length;
+        node.innerHTML = '';
+        for (var i = 0; i < lines.length; i++) {
+            if (i > 0)
+                node.appendChild(document.createTextNode('\n'));
+            node.appendChild(makeSpan(lines[i], '--line-index', i, '--line-total', count));
+        }
+    }
+    return {
+        count: count,
+        cleanup: function () { return restoreNode(node, originalText); }
+    };
+}
+function makeSpan(text, indexVar, index, totalVar, total) {
+    var span = document.createElement('span');
+    span.setAttribute('aria-hidden', 'true');
+    span.style.setProperty(indexVar, String(index));
+    span.style.setProperty(totalVar, String(total));
+    span.textContent = text;
+    return span;
+}
+function restoreNode(node, originalText) {
+    node.textContent = originalText;
+    node.removeAttribute('aria-label');
+    node.removeAttribute('data-split-original');
+    node.removeAttribute('data-split-by');
+}

package/dist/utils/taskUtils.js

@@ -67,5 +67,5 @@ export function typeIcon(type) {
  * "in_progress" → "In Progress"
  */
 export function statusLabel(status) {
-    return status.replace(/_/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+    return status.replace(/_/g, ' ').replace(/\b\w/g, function (c) { return c.toUpperCase(); });
 }

package/dist/utils/themeWipe.d.ts

@@ -0,0 +1,21 @@
+/**
+ * themeWipe — circular View Transition reveal from a click origin.
+ *
+ * Wraps document.startViewTransition, computes a covering radius from the
+ * click point, and animates ::view-transition-new(root) with a clip-path
+ * circle via WAAPI (~500ms, var(--motion-glide)).
+ *
+ * Falls back gracefully: if startViewTransition is unsupported or
+ * prefers-reduced-motion is set, applyTheme() runs synchronously with no
+ * animation.
+ */
+/**
+ * @param event - The click (or pointer) event that triggered the theme toggle.
+ *                Used to anchor the reveal circle. Pass null to default to
+ *                screen center.
+ * @param applyTheme - Callback that performs the actual theme mutation
+ *                     (e.g. set data-theme, update localStorage). Called
+ *                     inside the startViewTransition callback so the snapshot
+ *                     captures the old state and the new DOM is recorded after.
+ */
+export declare function themeWipe(event: MouseEvent | PointerEvent | null, applyTheme: () => void): Promise<void>;

package/dist/utils/themeWipe.js

@@ -0,0 +1,94 @@
+/**
+ * themeWipe — circular View Transition reveal from a click origin.
+ *
+ * Wraps document.startViewTransition, computes a covering radius from the
+ * click point, and animates ::view-transition-new(root) with a clip-path
+ * circle via WAAPI (~500ms, var(--motion-glide)).
+ *
+ * Falls back gracefully: if startViewTransition is unsupported or
+ * prefers-reduced-motion is set, applyTheme() runs synchronously with no
+ * animation.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var DURATION = 500;
+var EASING = 'cubic-bezier(0.16, 1, 0.3, 1)'; // --motion-glide fallback
+/**
+ * @param event - The click (or pointer) event that triggered the theme toggle.
+ *                Used to anchor the reveal circle. Pass null to default to
+ *                screen center.
+ * @param applyTheme - Callback that performs the actual theme mutation
+ *                     (e.g. set data-theme, update localStorage). Called
+ *                     inside the startViewTransition callback so the snapshot
+ *                     captures the old state and the new DOM is recorded after.
+ */
+export function themeWipe(event, applyTheme) {
+    return __awaiter(this, void 0, Promise, function () {
+        var prefersReduced, x, y, endRadius, transition, resolvedEasing;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    prefersReduced = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+                    if (prefersReduced || !document.startViewTransition) {
+                        applyTheme();
+                        return [2 /*return*/];
+                    }
+                    x = event ? event.clientX : window.innerWidth / 2;
+                    y = event ? event.clientY : window.innerHeight / 2;
+                    endRadius = Math.hypot(Math.max(x, window.innerWidth - x), Math.max(y, window.innerHeight - y));
+                    transition = document.startViewTransition(applyTheme);
+                    // Wait until both snapshots are captured before animating
+                    return [4 /*yield*/, transition.ready];
+                case 1:
+                    // Wait until both snapshots are captured before animating
+                    _a.sent();
+                    resolvedEasing = getComputedStyle(document.documentElement)
+                        .getPropertyValue('--motion-glide')
+                        .trim() || EASING;
+                    document.documentElement.animate([
+                        { clipPath: "circle(0px at ".concat(x, "px ").concat(y, "px)") },
+                        { clipPath: "circle(".concat(endRadius, "px at ").concat(x, "px ").concat(y, "px)") }
+                    ], {
+                        duration: DURATION,
+                        easing: resolvedEasing,
+                        pseudoElement: '::view-transition-new(root)'
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    });
+}

package/dist/utils/viewTransition.d.ts

@@ -0,0 +1,23 @@
+/**
+ * viewTransition — SvelteKit onNavigate helper.
+ *
+ * Drop this into +layout.svelte to wrap each client-side navigation with
+ * document.startViewTransition, giving the browser a chance to animate
+ * between pages using the View Transitions API.
+ *
+ * Usage in +layout.svelte:
+ *   <script>
+ *     import { onNavigate } from '$app/navigation';
+ *     import { viewTransition } from '../../../dist';
+ *     viewTransition(onNavigate);
+ *   </script>
+ *
+ * Falls back silently: if startViewTransition is unsupported, the navigation
+ * proceeds normally. prefers-reduced-motion is honoured automatically by the
+ * browser's View Transitions implementation; no extra guard is needed here.
+ */
+type OnNavigateCallback = (callback: (navigation: {
+    complete: Promise<void>;
+}) => void | (() => void) | Promise<void | (() => void)>) => void;
+export declare function viewTransition(onNavigate: OnNavigateCallback): void;
+export {};