nativecorejs 0.1.0

package/dist/core/router.js

@@ -0,0 +1,424 @@
+import { bustCache } from '../utils/cacheBuster.js';
+export class Router {
+    routes = {};
+    currentRoute = null;
+    middlewares = [];
+    htmlCache = new Map();
+    pageScripts = {};
+    navigationController = null;
+    isNavigating = false;
+    renderedLayoutPath = null;
+    constructor() {
+        if ('scrollRestoration' in window.history) {
+            window.history.scrollRestoration = 'manual';
+        }
+        window.addEventListener('popstate', (e) => {
+            this.handleRoute(window.location.pathname, e.state);
+        });
+        document.addEventListener('click', (e) => {
+            const target = e.target;
+            const link = target.closest('a');
+            if (link && link.tagName === 'A') {
+                const href = link.getAttribute('href');
+                if (!href)
+                    return;
+                if (href.startsWith('http://') || href.startsWith('https://') ||
+                    href.startsWith('mailto:') || href.startsWith('tel:') ||
+                    href.startsWith('#')) {
+                    return;
+                }
+                if (link.target === '_blank' || link.hasAttribute('data-external')) {
+                    return;
+                }
+                e.preventDefault();
+                this.navigate(href);
+            }
+        });
+    }
+    register(path, htmlFile, controller = null, options = {}) {
+        this.routes[path] = { htmlFile, controller, ...options };
+        return this;
+    }
+    cache(policy) {
+        const paths = Object.keys(this.routes);
+        const last = paths[paths.length - 1];
+        if (last)
+            this.routes[last].cachePolicy = policy;
+        return this;
+    }
+    bustCache(path) {
+        if (path) {
+            const config = this.routes[path];
+            if (config) {
+                this.htmlCache.delete(config.htmlFile);
+                if (config.layout) {
+                    const layoutConfig = this.routes[config.layout];
+                    if (layoutConfig) {
+                        this.htmlCache.delete(layoutConfig.htmlFile);
+                    }
+                }
+            }
+        }
+        else {
+            this.htmlCache.clear();
+        }
+    }
+    async prefetch(path) {
+        const route = this.matchRoute(path);
+        if (!route)
+            return;
+        const requests = [
+            this.fetchHTML(route.config.htmlFile, route.config.cachePolicy, true)
+        ];
+        const layoutRoute = this.getLayoutRoute(route);
+        if (layoutRoute) {
+            requests.push(this.fetchHTML(layoutRoute.config.htmlFile, layoutRoute.config.cachePolicy, true));
+        }
+        await Promise.allSettled(requests);
+    }
+    use(middleware) {
+        this.middlewares.push(middleware);
+        return this;
+    }
+    navigate(path, state = {}) {
+        const browserPath = this.normalizeBrowserPath(path);
+        if (this.navigationController) {
+            this.navigationController.abort();
+        }
+        this.navigationController = new AbortController();
+        window.history.pushState(state, '', browserPath);
+        this.handleRoute(browserPath, state);
+    }
+    replace(path, state = {}) {
+        const browserPath = this.normalizeBrowserPath(path);
+        window.history.replaceState(state, '', browserPath);
+        this.handleRoute(browserPath, state);
+    }
+    reload() {
+        this.isNavigating = false;
+        if (this.navigationController) {
+            this.navigationController.abort();
+        }
+        const currentPath = window.location.pathname;
+        this.handleRoute(currentPath, {});
+    }
+    back() {
+        window.history.back();
+    }
+    async handleRoute(path, state = {}) {
+        if (this.isNavigating && this.navigationController?.signal.aborted === false) {
+            return;
+        }
+        this.isNavigating = true;
+        const route = this.matchRoute(path);
+        if (!route) {
+            this.handle404(path);
+            this.isNavigating = false;
+            return;
+        }
+        if (this.navigationController?.signal.aborted) {
+            this.isNavigating = false;
+            return;
+        }
+        for (const middleware of this.middlewares) {
+            const result = await middleware(route, state);
+            if (result === false) {
+                this.isNavigating = false;
+                return;
+            }
+        }
+        if (this.navigationController?.signal.aborted) {
+            this.isNavigating = false;
+            return;
+        }
+        const previousRoute = this.currentRoute;
+        this.currentRoute = route;
+        await this.loadPage(route, state, previousRoute);
+        this.isNavigating = false;
+    }
+    async loadPage(route, state = {}, previousRoute = null) {
+        const mainContent = document.getElementById('main-content');
+        const progressBar = document.getElementById('page-progress');
+        if (!mainContent) {
+            console.error('main-content element not found');
+            return;
+        }
+        try {
+            const isPrerenderedInitialRoute = previousRoute === null &&
+                mainContent.getAttribute('data-prerendered-route') === route.path &&
+                !route.config.layout;
+            if (progressBar) {
+                progressBar.classList.add('loading');
+            }
+            this.resetScrollPosition(mainContent);
+            if (previousRoute?.path && this.pageScripts[previousRoute.path]?.cleanup) {
+                this.pageScripts[previousRoute.path].cleanup?.();
+            }
+            if (!isPrerenderedInitialRoute) {
+                mainContent.classList.add('page-transition-exit');
+                await new Promise(resolve => setTimeout(resolve, 50));
+                const contentTarget = await this.resolveContentTarget(mainContent, route);
+                const html = await this.fetchHTML(route.config.htmlFile, route.config.cachePolicy);
+                contentTarget.innerHTML = html;
+                mainContent.classList.remove('page-transition-exit');
+                mainContent.classList.add('page-transition-enter');
+            }
+            if (route.config.controller) {
+                const cleanup = await route.config.controller(route.params, state);
+                this.pageScripts[route.path] = {
+                    cleanup: typeof cleanup === 'function' ? cleanup : undefined
+                };
+            }
+            if (isPrerenderedInitialRoute) {
+                mainContent.removeAttribute('data-prerendered-route');
+            }
+            window.dispatchEvent(new CustomEvent('pageloaded', { detail: route }));
+            this.resetScrollPosition(mainContent);
+            if (progressBar) {
+                setTimeout(() => progressBar.classList.remove('loading'), 200);
+            }
+            if (!isPrerenderedInitialRoute) {
+                setTimeout(() => {
+                    mainContent.classList.remove('page-transition-enter');
+                }, 150);
+            }
+        }
+        catch (error) {
+            console.error('Error loading page:', error);
+            if (progressBar) {
+                progressBar.classList.remove('loading');
+            }
+            this.handle404(route.path);
+        }
+    }
+    async fetchHTML(file, policy, allowPrefetchCache = false) {
+        const entry = this.htmlCache.get(file);
+        const now = Date.now();
+        const ttlMs = this.resolveCacheTtl(policy, entry) * 1000;
+        const isFresh = entry && ttlMs > 0 && now - entry.cachedAt < ttlMs;
+        const isStale = entry && ttlMs > 0 && !isFresh;
+        if (isStale && policy?.revalidate) {
+            this.refreshInBackground(file, policy.ttl);
+            return entry.html;
+        }
+        if (isFresh)
+            return entry.html;
+        const response = await fetch(bustCache(file), { cache: 'no-store' });
+        if (!response.ok)
+            throw new Error(`Failed to load ${file}`);
+        const html = await response.text();
+        if (ttlMs > 0 || allowPrefetchCache) {
+            this.htmlCache.set(file, {
+                html,
+                cachedAt: now,
+                ttl: policy?.ttl ?? entry?.ttl ?? 30
+            });
+        }
+        return html;
+    }
+    async refreshInBackground(file, ttl) {
+        try {
+            const response = await fetch(bustCache(file), { cache: 'no-store' });
+            if (!response.ok)
+                return;
+            const html = await response.text();
+            this.htmlCache.set(file, { html, cachedAt: Date.now(), ttl });
+        }
+        catch {
+        }
+    }
+    matchRoute(path) {
+        const normalizedPath = this.normalizeRoutePath(path);
+        if (this.routes[normalizedPath]) {
+            return { path: normalizedPath, params: {}, config: this.routes[normalizedPath] };
+        }
+        for (const [routePath, config] of Object.entries(this.routes)) {
+            const params = this.extractParams(routePath, normalizedPath);
+            if (params) {
+                return { path: routePath, params, config };
+            }
+        }
+        return null;
+    }
+    extractParams(routePath, actualPath) {
+        const routeParts = this.splitPath(routePath);
+        const actualParts = this.splitPath(actualPath);
+        const params = {};
+        let routeIndex = 0;
+        let actualIndex = 0;
+        while (routeIndex < routeParts.length) {
+            const routePart = routeParts[routeIndex];
+            const actualPart = actualParts[actualIndex];
+            if (routePart === '*') {
+                params.wildcard = actualParts.slice(actualIndex).join('/');
+                actualIndex = actualParts.length;
+                routeIndex++;
+                continue;
+            }
+            if (routePart.startsWith(':') && routePart.endsWith('?')) {
+                const paramName = routePart.slice(1, -1);
+                if (actualPart !== undefined) {
+                    params[paramName] = actualPart;
+                    actualIndex++;
+                }
+                routeIndex++;
+                continue;
+            }
+            if (actualPart === undefined) {
+                return null;
+            }
+            if (routePart.startsWith(':')) {
+                params[routePart.slice(1)] = actualPart;
+                routeIndex++;
+                actualIndex++;
+                continue;
+            }
+            if (routePart !== actualPart) {
+                return null;
+            }
+            routeIndex++;
+            actualIndex++;
+        }
+        return actualIndex === actualParts.length ? params : null;
+    }
+    handle404(path) {
+        const mainContent = document.getElementById('main-content');
+        if (mainContent) {
+            this.resetScrollPosition(mainContent);
+            mainContent.innerHTML = `
+                <div style="
+                    display: flex;
+                    flex-direction: column;
+                    align-items: center;
+                    justify-content: center;
+                    min-height: 60vh;
+                    text-align: center;
+                    padding: var(--spacing-xl, 2rem);
+                ">
+                    <div style="
+                        font-size: 8rem;
+                        font-weight: 700;
+                        color: var(--primary, #0f766e);
+                        line-height: 1;
+                        margin-bottom: var(--spacing-md, 1rem);
+                    ">404</div>
+                    <h1 style="
+                        font-size: 2rem;
+                        font-weight: 600;
+                        color: var(--text-primary, #111827);
+                        margin-bottom: var(--spacing-sm, 0.75rem);
+                    ">Page Not Found</h1>
+                    <p style="
+                        font-size: 1.1rem;
+                        color: var(--text-secondary, #4b5563);
+                        max-width: 500px;
+                        margin-bottom: var(--spacing-lg, 1.5rem);
+                    ">
+                        The page <code style="
+                            background: var(--background-secondary, #f3f4f6);
+                            padding: 0.2rem 0.5rem;
+                            border-radius: var(--radius-sm, 0.375rem);
+                            color: var(--primary, #0f766e);
+                        ">${path}</code> could not be found.
+                    </p>
+                    <button onclick="window.history.back()" style="
+                        display: inline-flex;
+                        align-items: center;
+                        gap: 0.5rem;
+                        padding: var(--spacing-sm, 0.75rem) var(--spacing-lg, 1.5rem);
+                        background: var(--primary, #0f766e);
+                        color: white;
+                        border: none;
+                        border-radius: var(--radius-md, 0.5rem);
+                        font-weight: 500;
+                        font-size: 1rem;
+                        cursor: pointer;
+                        transition: all 0.2s ease;
+                    " onmouseover="this.style.transform='translateY(-2px)'; this.style.boxShadow='var(--shadow-md, 0 10px 20px rgba(0,0,0,0.12))'"
+                       onmouseout="this.style.transform='translateY(0)'; this.style.boxShadow='none'">
+                        <span><</span> Go Back
+                    </button>
+                </div>
+            `;
+        }
+    }
+    start() {
+        const browserPath = this.normalizeBrowserPath(window.location.pathname + window.location.search + window.location.hash);
+        if (browserPath !== window.location.pathname + window.location.search + window.location.hash) {
+            window.history.replaceState(window.history.state, '', browserPath);
+        }
+        this.handleRoute(browserPath);
+    }
+    getCurrentRoute() {
+        return this.currentRoute;
+    }
+    async resolveContentTarget(mainContent, route) {
+        const layoutRoute = this.getLayoutRoute(route);
+        if (!layoutRoute) {
+            this.renderedLayoutPath = null;
+            return mainContent;
+        }
+        const needsLayoutRender = this.renderedLayoutPath !== layoutRoute.path ||
+            !mainContent.querySelector('#route-outlet');
+        if (needsLayoutRender) {
+            const layoutHtml = await this.fetchHTML(layoutRoute.config.htmlFile, layoutRoute.config.cachePolicy);
+            mainContent.innerHTML = layoutHtml;
+            this.renderedLayoutPath = layoutRoute.path;
+        }
+        const outlet = mainContent.querySelector('#route-outlet');
+        if (!outlet) {
+            throw new Error(`Layout route "${layoutRoute.path}" is missing a #route-outlet element`);
+        }
+        return outlet;
+    }
+    getLayoutRoute(route) {
+        const layoutPath = route.config.layout;
+        if (!layoutPath)
+            return null;
+        const layoutConfig = this.routes[layoutPath];
+        if (!layoutConfig) {
+            throw new Error(`Layout route "${layoutPath}" is not registered`);
+        }
+        return {
+            path: layoutPath,
+            params: {},
+            config: layoutConfig
+        };
+    }
+    splitPath(path) {
+        const trimmed = path.replace(/^\/+|\/+$/g, '');
+        return trimmed ? trimmed.split('/') : [];
+    }
+    normalizeRoutePath(path) {
+        const cleanedPath = path.replace(/[?#].*$/, '').replace(/\/+$/, '');
+        return cleanedPath || '/';
+    }
+    normalizeBrowserPath(path) {
+        const [pathnameWithQuery, hash = ''] = path.split('#');
+        const [pathname = '/', query = ''] = pathnameWithQuery.split('?');
+        if (!pathname || pathname === '/' || pathname.endsWith('/') || /\.[a-z0-9]+$/i.test(pathname)) {
+            return path;
+        }
+        const normalizedPath = `${pathname}/`;
+        const querySuffix = query ? `?${query}` : '';
+        const hashSuffix = hash ? `#${hash}` : '';
+        return `${normalizedPath}${querySuffix}${hashSuffix}`;
+    }
+    resolveCacheTtl(policy, entry) {
+        return policy?.ttl ?? entry?.ttl ?? 0;
+    }
+    resetScrollPosition(mainContent) {
+        window.scrollTo(0, 0);
+        if (mainContent) {
+            mainContent.scrollTop = 0;
+            mainContent.scrollLeft = 0;
+            const scrollContainer = mainContent.closest('.main-content');
+            if (scrollContainer) {
+                scrollContainer.scrollTop = 0;
+                scrollContainer.scrollLeft = 0;
+            }
+        }
+    }
+}
+const router = new Router();
+export default router;

package/dist/core/state.d.ts

@@ -0,0 +1,18 @@
+export interface State<T> {
+    value: T;
+    set(value: T | ((prev: T) => T)): void;
+    watch(callback: (value: T) => void): () => void;
+}
+export interface ComputedState<T> {
+    readonly value: T;
+    watch(callback: (value: T) => void): () => void;
+    dispose(): void;
+}
+export type EffectCleanup = void | (() => void);
+export type EffectCallback = () => EffectCleanup;
+export declare function useState<T>(initialValue: T): State<T>;
+export declare function createStates<T extends Record<string, any>>(initialStates: T): {
+    [K in keyof T]: State<T[K]>;
+};
+export declare function computed<T>(computeFn: () => T): ComputedState<T>;
+export declare function effect(effectFn: EffectCallback): () => void;

package/dist/core/state.js

@@ -0,0 +1,153 @@
+let currentTracker = null;
+function createState(initialValue) {
+    let currentValue = initialValue;
+    const subscribers = new Set();
+    const state = {
+        get value() {
+            return currentValue;
+        },
+        set value(newValue) {
+            if (Object.is(currentValue, newValue))
+                return;
+            currentValue = newValue;
+            notify();
+        },
+        set(valueOrUpdater) {
+            const newValue = typeof valueOrUpdater === 'function'
+                ? valueOrUpdater(currentValue)
+                : valueOrUpdater;
+            if (Object.is(currentValue, newValue))
+                return;
+            currentValue = newValue;
+            notify();
+        },
+        watch(callback) {
+            const wrappedCallback = () => callback(currentValue);
+            subscribers.add(wrappedCallback);
+            return () => subscribers.delete(wrappedCallback);
+        }
+    };
+    function notify() {
+        subscribers.forEach(fn => fn());
+    }
+    return state;
+}
+export function useState(initialValue) {
+    const state = createState(initialValue);
+    const trackedState = {
+        get value() {
+            if (currentTracker) {
+                currentTracker.accessed.add(state);
+            }
+            return state.value;
+        },
+        set value(newValue) {
+            state.value = newValue;
+        },
+        set: state.set.bind(state),
+        watch: state.watch.bind(state)
+    };
+    return trackedState;
+}
+export function createStates(initialStates) {
+    const states = {};
+    for (const [key, value] of Object.entries(initialStates)) {
+        states[key] = useState(value);
+    }
+    return states;
+}
+export function computed(computeFn) {
+    const derivedState = createState(undefined);
+    const trackedDeps = new Set();
+    const depUnsubscribers = new Map();
+    let isComputing = false;
+    const tracker = {
+        accessed: new Set()
+    };
+    recompute();
+    function recompute() {
+        if (isComputing)
+            return;
+        isComputing = true;
+        tracker.accessed.clear();
+        currentTracker = tracker;
+        try {
+            const newValue = computeFn();
+            derivedState.value = newValue;
+        }
+        finally {
+            currentTracker = null;
+            isComputing = false;
+        }
+        syncTrackedDependencies(trackedDeps, tracker.accessed, depUnsubscribers, recompute);
+    }
+    function dispose() {
+        depUnsubscribers.forEach(unsub => unsub());
+        depUnsubscribers.clear();
+        trackedDeps.clear();
+    }
+    return {
+        get value() {
+            if (currentTracker) {
+                currentTracker.accessed.add(derivedState);
+            }
+            return derivedState.value;
+        },
+        watch: derivedState.watch.bind(derivedState),
+        dispose,
+        set value(_) {
+            console.warn('Computed values are read-only. Cannot set value directly.');
+        }
+    };
+}
+export function effect(effectFn) {
+    const trackedDeps = new Set();
+    const depUnsubscribers = new Map();
+    const tracker = {
+        accessed: new Set()
+    };
+    let cleanup;
+    let isRunning = false;
+    runEffect();
+    return () => {
+        if (typeof cleanup === 'function') {
+            cleanup();
+        }
+        depUnsubscribers.forEach(unsub => unsub());
+        depUnsubscribers.clear();
+        trackedDeps.clear();
+    };
+    function runEffect() {
+        if (isRunning)
+            return;
+        isRunning = true;
+        tracker.accessed.clear();
+        currentTracker = tracker;
+        try {
+            if (typeof cleanup === 'function') {
+                cleanup();
+            }
+            cleanup = effectFn();
+        }
+        finally {
+            currentTracker = null;
+            isRunning = false;
+        }
+        syncTrackedDependencies(trackedDeps, tracker.accessed, depUnsubscribers, runEffect);
+    }
+}
+function syncTrackedDependencies(trackedDeps, nextDeps, depUnsubscribers, onDependencyChange) {
+    trackedDeps.forEach(dep => {
+        if (!nextDeps.has(dep)) {
+            depUnsubscribers.get(dep)?.();
+            depUnsubscribers.delete(dep);
+            trackedDeps.delete(dep);
+        }
+    });
+    nextDeps.forEach(dep => {
+        if (!trackedDeps.has(dep)) {
+            trackedDeps.add(dep);
+            depUnsubscribers.set(dep, dep.watch(() => onDependencyChange()));
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { Component, defineComponent } from './core/component.js';
+export { LoadingSpinner, NcA, NcAccordion, NcAccordionItem, NcAlert, NcAnimation, NcAutocomplete, NcAvatar, NcAvatarGroup, NcBadge, NcBottomNav, NcBottomNavItem, NcBreadcrumb, NcButton, NcCard, NcCheckbox, NcChip, NcCode, NcCollapsible, NcColorPicker, NcCopyButton, NcDatePicker, NcDiv, NcDivider, NcDrawer, NcDropdown, NcEmptyState, NcField, NcFileUpload, NcForm, NcImage, NcInput, NcKbd, NcNumberInput, NcMenu, NcMenuItem, NcModal, NcNavItem, NcOtpInput, NcPagination, NcPopover, NcProgress, NcProgressCircular, NcRadio, NcRating, NcRichText, NcScrollTop, NcSelect, NcSkeleton, NcSlider, NcSnackbar, NcSplash, NcStep, NcStepper, NcSwitch, NcTabItem, NcTable, NcTabs, NcTagInput, NcTextarea, NcTimePicker, NcTimeline, NcTimelineItem, NcTooltip } from './components/index.js';
+export { builtinComponentManifest, registerBuiltinComponents } from './components/builtinRegistry.js';
+export { GPUAnimation, addPassiveListener, animate, cleanupAnimation, createAnimationLoop, fadeIn, fadeOut, prepareForAnimation, rafThrottle, scaleIn, setGPUTransform, setTransformVars, slideIn, throttle } from './core/gpu-animation.js';
+export { Router } from './core/router.js';
+export { componentRegistry, initLazyComponents } from './core/lazyComponents.js';
+export { useState, createStates, computed, effect } from './core/state.js';
+export { bustCache, cacheVersion, importWithBust } from './utils/cacheBuster.js';
+export { dom } from './utils/dom.js';
+export { css, html } from './utils/templates.js';
+export { bindEvents, delegate, on, onChange, onClick, onInput, onSubmit, trackEvents, trackSubscriptions } from './utils/events.js';
+export type { ComponentConstructor, ComponentState } from './core/component.js';
+export type { CachePolicy, ControllerFunction, MiddlewareFunction, RouteConfig, RouteMatch } from './core/router.js';
+export type { ComputedState, EffectCallback, EffectCleanup, State } from './core/state.js';

package/dist/index.js

@@ -0,0 +1,11 @@
+export { Component, defineComponent } from './core/component.js';
+export { LoadingSpinner, NcA, NcAccordion, NcAccordionItem, NcAlert, NcAnimation, NcAutocomplete, NcAvatar, NcAvatarGroup, NcBadge, NcBottomNav, NcBottomNavItem, NcBreadcrumb, NcButton, NcCard, NcCheckbox, NcChip, NcCode, NcCollapsible, NcColorPicker, NcCopyButton, NcDatePicker, NcDiv, NcDivider, NcDrawer, NcDropdown, NcEmptyState, NcField, NcFileUpload, NcForm, NcImage, NcInput, NcKbd, NcNumberInput, NcMenu, NcMenuItem, NcModal, NcNavItem, NcOtpInput, NcPagination, NcPopover, NcProgress, NcProgressCircular, NcRadio, NcRating, NcRichText, NcScrollTop, NcSelect, NcSkeleton, NcSlider, NcSnackbar, NcSplash, NcStep, NcStepper, NcSwitch, NcTabItem, NcTable, NcTabs, NcTagInput, NcTextarea, NcTimePicker, NcTimeline, NcTimelineItem, NcTooltip } from './components/index.js';
+export { builtinComponentManifest, registerBuiltinComponents } from './components/builtinRegistry.js';
+export { GPUAnimation, addPassiveListener, animate, cleanupAnimation, createAnimationLoop, fadeIn, fadeOut, prepareForAnimation, rafThrottle, scaleIn, setGPUTransform, setTransformVars, slideIn, throttle } from './core/gpu-animation.js';
+export { Router } from './core/router.js';
+export { componentRegistry, initLazyComponents } from './core/lazyComponents.js';
+export { useState, createStates, computed, effect } from './core/state.js';
+export { bustCache, cacheVersion, importWithBust } from './utils/cacheBuster.js';
+export { dom } from './utils/dom.js';
+export { css, html } from './utils/templates.js';
+export { bindEvents, delegate, on, onChange, onClick, onInput, onSubmit, trackEvents, trackSubscriptions } from './utils/events.js';

package/dist/utils/cacheBuster.d.ts

@@ -0,0 +1,9 @@
+export declare const cacheVersion: string | number;
+export declare function bustCache(url: string): string;
+export declare function importWithBust(modulePath: string): Promise<any>;
+declare const _default: {
+    cacheVersion: string | number;
+    bustCache: typeof bustCache;
+    importWithBust: typeof importWithBust;
+};
+export default _default;

package/dist/utils/cacheBuster.js

@@ -0,0 +1,12 @@
+const isDevelopment = window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1';
+export const cacheVersion = isDevelopment
+    ? Date.now()
+    : '0.1.0';
+export function bustCache(url) {
+    const separator = url.includes('?') ? '&' : '?';
+    return `${url}${separator}v=${cacheVersion}`;
+}
+export async function importWithBust(modulePath) {
+    return import(bustCache(modulePath));
+}
+export default { cacheVersion, bustCache, importWithBust };

package/dist/utils/dom.d.ts

@@ -0,0 +1,16 @@
+export declare const dom: {
+    query: <T extends Element = Element>(selector: string) => T | null;
+    queryAll: <T extends Element = Element>(selector: string) => NodeListOf<T>;
+    $: <T extends Element = Element>(selector: string) => T | null;
+    $$: <T extends Element = Element>(selector: string) => NodeListOf<T>;
+    within: <T extends Element = Element>(parent: Element | ShadowRoot | string, selector: string) => T | null;
+    withinAll: <T extends Element = Element>(parent: Element | ShadowRoot | string, selector: string) => NodeListOf<T> | T[];
+    create: <K extends keyof HTMLElementTagNameMap>(tag: K, attrs?: Record<string, string> | null, ...children: Array<string | Node>) => HTMLElementTagNameMap[K];
+    addClass: (element: Element | string | null, ...classes: string[]) => void;
+    removeClass: (element: Element | string | null, ...classes: string[]) => void;
+    toggleClass: (element: Element | string | null, className: string, force?: boolean) => void;
+    show: (element: Element | string | null) => void;
+    hide: (element: Element | string | null) => void;
+    listen: (selectorOrElement: string | Element | null, eventName: string, handler: (event: any) => void, options?: boolean | AddEventListenerOptions) => () => void;
+};
+export default dom;