@riverty/web-components 6.3.0 → 6.3.1

package/dist/collection/utils/theming.js

@@ -0,0 +1,103 @@
+import StyleObserver from "style-observer";
+// Track observers per theme context element
+const contextObservers = new Map();
+// Track which elements already have inverse theme setup to avoid duplicates
+const inverseThemeTargets = new WeakMap();
+// Special design token defined for this purpose. Defined as either 'light' or 'dark'.
+const THEME_STATE_PROPERTY = '--r-internal-theme-state';
+/**
+ * Sets up an inverse theme relationship between a target element and its theme context element.
+ * The target will automatically update its theme to be the inverse of its parent context.
+ * @param targetElement Element that should have inverse theme
+ * @param themeContextElement Element that contains the theme context
+ */
+export const setupInverseThemeAwareness = (targetElement, themeContextElement) => {
+    if (!themeContextElement || !targetElement)
+        return;
+    // Check if this target is already set up with this context
+    const existingTargets = inverseThemeTargets.get(themeContextElement);
+    if (existingTargets === null || existingTargets === void 0 ? void 0 : existingTargets.has(targetElement))
+        return;
+    // Store this target as set up
+    if (!existingTargets) {
+        inverseThemeTargets.set(themeContextElement, new Set([targetElement]));
+    }
+    else {
+        existingTargets.add(targetElement);
+    }
+    // Find or create observer for this context
+    let observer = contextObservers.get(themeContextElement);
+    if (!observer) {
+        const observerCallback = (records) => {
+            const record = records[0];
+            if (!record)
+                return;
+            const theme = resolveTheme(record.value);
+            const inverseTheme = theme === 'dark' ? 'light' : 'dark';
+            // Update all targets for this context
+            const targets = inverseThemeTargets.get(themeContextElement);
+            targets === null || targets === void 0 ? void 0 : targets.forEach(target => {
+                target.setAttribute('data-theme', inverseTheme);
+            });
+        };
+        observer = new StyleObserver(observerCallback, {
+            target: themeContextElement,
+            properties: THEME_STATE_PROPERTY
+        });
+        contextObservers.set(themeContextElement, observer);
+        // Immediate check for initial value
+        const computedStyle = window.getComputedStyle(themeContextElement);
+        const initialValue = computedStyle.getPropertyValue(THEME_STATE_PROPERTY);
+        observerCallback([{
+                target: themeContextElement,
+                property: THEME_STATE_PROPERTY,
+                value: initialValue,
+                oldValue: null
+            }]);
+    }
+    else {
+        // Observer exists already, just need to set initial theme on the new target
+        const computedStyle = window.getComputedStyle(themeContextElement);
+        const initialValue = computedStyle.getPropertyValue(THEME_STATE_PROPERTY);
+        const theme = resolveTheme(initialValue);
+        const inverseTheme = theme === 'dark' ? 'light' : 'dark';
+        targetElement.setAttribute('data-theme', inverseTheme);
+    }
+};
+/**
+ * Removes the inverse theme relationship between a target element and its theme context element.
+ * This function cleans up any observers and references created by setupInverseThemeAwareness.
+ * @param targetElement Element that has inverse theme
+ * @param themeContextElement Element that contains the theme context
+ */
+export const stopInverseThemeAwareness = (targetElement, themeContextElement) => {
+    if (!themeContextElement || !targetElement)
+        return;
+    // Get the set of targets for this context
+    const targets = inverseThemeTargets.get(themeContextElement);
+    if (!targets || !targets.has(targetElement))
+        return;
+    // Remove the target from the set
+    targets.delete(targetElement);
+    // If no more targets for this context, clean up the observer
+    if (targets.size === 0) {
+        inverseThemeTargets.delete(themeContextElement);
+        const observer = contextObservers.get(themeContextElement);
+        if (observer) {
+            // Remove the observer (StyleObserver has no disconnect method, it auto-cleans)
+            contextObservers.delete(themeContextElement);
+        }
+    }
+};
+/**
+ * Resolves theme based on CSS property value
+ * @param value - The value of the CSS property (should be 'light' or 'dark')
+ * @returns The resolved theme
+ */
+const resolveTheme = (value) => {
+    const trimmedValue = value === null || value === void 0 ? void 0 : value.trim();
+    if (trimmedValue === 'dark') {
+        return 'dark';
+    }
+    return 'light';
+};

package/dist/collection/utils/version-checker.js

@@ -0,0 +1,33 @@
+export async function checkForUpdates(packageName, currentVersion) {
+    if (typeof window === 'undefined' || !window.localStorage)
+        return;
+    const storageKey = `riverty-version-check:${packageName}`;
+    const lastCheck = localStorage.getItem(storageKey);
+    const oneDay = 24 * 60 * 60 * 1000;
+    if (lastCheck && Date.now() - parseInt(lastCheck, 10) < oneDay) {
+        return;
+    }
+    localStorage.setItem(storageKey, Date.now().toString());
+    const registryUrl = 'https://registry.npmjs.org';
+    try {
+        const response = await fetch(`${registryUrl}/${packageName}/latest`, {
+            signal: AbortSignal.timeout(5000)
+        });
+        if (!response.ok)
+            return;
+        const data = await response.json();
+        const latestVersion = data.version;
+        if (!latestVersion || latestVersion === currentVersion)
+            return;
+        const currentParts = currentVersion.split('.').map(Number);
+        const latestParts = latestVersion.split('.').map(Number);
+        const isMajorUpdate = latestParts[0] > currentParts[0];
+        console.warn(`%c⚠️ ${packageName} update available\n` +
+            `%c  Current: ${currentVersion} → Latest: ${latestVersion}\n` +
+            (isMajorUpdate ? `%c  ⚠️ This is a MAJOR version with breaking changes!\n` : '') +
+            `%c  Run: npm install ${packageName}@latest`, 'color: #f59e0b; font-weight: bold; font-size: 14px;', 'color: #6b7280;', isMajorUpdate ? 'color: #ef4444; font-weight: bold;' : '', 'color: #3b82f6;');
+    }
+    catch (_a) {
+        // Silently fail - version check is non-critical
+    }
+}

package/dist/esm/app-globals-DQuL1Twl.js

@@ -0,0 +1,3 @@
+const globalScripts = () => {};
+
+export { globalScripts as g };

package/dist/esm/focusable-ky1yonnS.js

@@ -0,0 +1,26 @@
+function focusableElements(root) {
+    const selectors = [
+        'a[href]',
+        'button:not([disabled])',
+        'textarea:not([disabled])',
+        'input:not([disabled])',
+        'select:not([disabled])',
+        '[tabindex]:not([tabindex="-1"])',
+        'r-button',
+        'r-checkbox',
+        'r-radio-button',
+        'r-input',
+        'r-textarea',
+        'r-select',
+        'r-input-code',
+        'r-input-date',
+        'r-input-password',
+        'r-input-phone-number'
+    ];
+    return Array.from(root.querySelectorAll(selectors.join(',')))
+        .filter((el) => el instanceof HTMLElement &&
+        !el.hasAttribute('disabled') &&
+        !el.getAttribute('aria-hidden')) || null;
+}
+
+export { focusableElements as f };

package/dist/esm/formData-DvLT8-y3.js

@@ -0,0 +1,42 @@
+function appendControlToFormData(controlOrControls, formData) {
+    var _a, _b, _c;
+    const controls = Array.isArray(controlOrControls)
+        ? controlOrControls
+        : [controlOrControls];
+    for (const control of controls) {
+        const name = control.name;
+        if (!name)
+            continue;
+        if (control.disabled)
+            continue;
+        const tag = (_b = (_a = control.tagName) === null || _a === void 0 ? void 0 : _a.toUpperCase) === null || _b === void 0 ? void 0 : _b.call(_a);
+        if (tag === 'BUTTON' || tag === 'FIELDSET')
+            continue;
+        let valueToAppend = '';
+        switch (control.type) {
+            case 'checkbox':
+            case 'radio':
+                if (!control.checked)
+                    continue;
+                valueToAppend = control.value || 'on';
+                break;
+            case 'file':
+                if (control.files && control.files.length > 0) {
+                    for (const file of control.files) {
+                        formData.append(name, file);
+                    }
+                    continue;
+                }
+                else {
+                    formData.append(name, new File([], ''));
+                    continue;
+                }
+            default:
+                valueToAppend = (_c = control.value) !== null && _c !== void 0 ? _c : '';
+                break;
+        }
+        formData.append(name, valueToAppend);
+    }
+}
+
+export { appendControlToFormData as a };