@ubean/runtime 0.1.1 → 0.1.3

package/dist/index.js

@@ -0,0 +1,364 @@
+import { $ as setI18nConfig, A as initCachedViewsFromRoutes, B as defineLocale, C as disablePageCache, D as getCachedViewNames, E as getCacheEnabled, F as resetRouteCache, G as getI18nConfig, H as detectLocale, I as useCacheViews, J as getLocaleName, K as getLocale, L as createUbeanRouter, M as isCacheEnabled, N as isPageCached, O as getExcludedViewNames, P as isPageExcluded, Q as onLocaleChange, R as addLocale, S as useReloadSignal, T as excludePageCache, U as extractLocaleFromPath, V as detectBrowserLocale, W as getDefaultLocale, X as localizePath, Y as getRegisteredLocales, Z as mergeLocale, _ as getReloadCounter, a as createUbeanSSRApp, at as useSwitchLocalePath, b as setPageTransition, c as useSeoMeta, d as getNavigationType, et as setLocale, f as supportsViewTransitions, g as getPageTransitionName, h as clearPageTransition, i as createUbeanApp, it as useLocalePath, j as invalidatePageCache, k as includePageCache, l as useUnheadHead, m as withViewTransition, n as Link, nt as t, o as usePage, p as useViewTransitionState, q as getLocaleDir, r as PageView, rt as useI18n, s as useRouter, t as Head, tt as switchLocalePath, u as useViewTransition, v as isReloading, w as enablePageCache, x as usePageTransition, y as reloadPage, z as clearLocales } from "./app-dx92OPRP.js";
+import { applyAppConfig, createDefaultAppConfig, defineApp } from "./define-app.js";
+import { injectHead, injectHead as injectHead$1 } from "@unhead/vue";
+import { createHead as createClientHead } from "@unhead/vue/client";
+import { createHead as createServerHead } from "@unhead/vue/server";
+import { defineDataKey as defineDataKey$1 } from "@ubean/pages";
+import { createApp, defineComponent, h } from "vue";
+//#region src/client.ts
+const _global$2 = globalThis;
+function getInitialPageData() {
+	if (typeof _global$2.document === "undefined") return null;
+	const el = _global$2.document.getElementById("__UBEAN_PAGE_DATA__");
+	if (!el) return _global$2.__UBEAN_PAGE_DATA__ ?? null;
+	try {
+		return JSON.parse(el.textContent || "null");
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/head.ts
+function useHeadInstance() {
+	return injectHead$1();
+}
+//#endregion
+//#region src/composables.ts
+const _global$1 = globalThis;
+function createDataCacheStore() {
+	const cache = /* @__PURE__ */ new Map();
+	const tagIndex = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	function notify() {
+		for (const fn of listeners) fn();
+	}
+	return {
+		get(key) {
+			return cache.get(key)?.data;
+		},
+		set(key, value, tags) {
+			cache.set(key, {
+				data: value,
+				timestamp: Date.now(),
+				tags
+			});
+			if (tags) for (const tag of tags) {
+				let set = tagIndex.get(tag);
+				if (!set) {
+					set = /* @__PURE__ */ new Set();
+					tagIndex.set(tag, set);
+				}
+				set.add(key);
+			}
+			notify();
+		},
+		has(key) {
+			return cache.has(key);
+		},
+		invalidate(keyOrTag) {
+			let count = 0;
+			if (typeof keyOrTag === "string") {
+				if (cache.has(keyOrTag)) {
+					const entry = cache.get(keyOrTag);
+					if (entry.tags) for (const t of entry.tags) {
+						const ts = tagIndex.get(t);
+						if (ts) ts.delete(keyOrTag);
+					}
+					cache.delete(keyOrTag);
+					count = 1;
+				}
+				const keys = tagIndex.get(keyOrTag);
+				if (keys) {
+					for (const k of keys) {
+						const entry = cache.get(k);
+						if (entry) {
+							if (entry.tags) for (const t of entry.tags) {
+								const ts = tagIndex.get(t);
+								if (ts) ts.delete(k);
+							}
+							cache.delete(k);
+							count++;
+						}
+					}
+					tagIndex.delete(keyOrTag);
+				}
+			} else {
+				const entry = cache.get(keyOrTag);
+				if (entry) {
+					if (entry.tags) for (const t of entry.tags) {
+						const ts = tagIndex.get(t);
+						if (ts) ts.delete(keyOrTag);
+					}
+					cache.delete(keyOrTag);
+					count = 1;
+				}
+			}
+			if (count > 0) notify();
+			return count;
+		},
+		clear() {
+			cache.clear();
+			tagIndex.clear();
+			notify();
+		},
+		subscribe(fn) {
+			listeners.add(fn);
+			return () => listeners.delete(fn);
+		},
+		getTimestamp(key) {
+			return cache.get(key)?.timestamp;
+		}
+	};
+}
+function createUseAsyncData(store) {
+	return function useAsyncData(keyOrFetcher, fetcherOrOptions, options) {
+		let key;
+		let fetcher;
+		let opts = {};
+		if (typeof keyOrFetcher === "string") {
+			key = keyOrFetcher;
+			fetcher = fetcherOrOptions;
+			opts = options || {};
+		} else {
+			fetcher = keyOrFetcher;
+			key = fetcherOrOptions?.key || Math.random().toString(36).slice(2);
+			opts = fetcherOrOptions || {};
+		}
+		const state = {
+			data: { value: store.get(key) ?? (opts.default ? opts.default() : void 0) },
+			error: { value: null },
+			loading: { value: false }
+		};
+		async function execute() {
+			state.loading.value = true;
+			state.error.value = null;
+			try {
+				const raw = await fetcher();
+				const value = opts.transform ? opts.transform(raw) : raw;
+				store.set(key, value, opts.tags);
+				state.data.value = value;
+			} catch (err) {
+				state.error.value = err instanceof Error ? err : new Error(String(err));
+			} finally {
+				state.loading.value = false;
+			}
+		}
+		function invalidate() {
+			store.invalidate(key);
+		}
+		if (!opts.lazy) {
+			if (!store.has(key)) execute();
+		}
+		store.subscribe(() => {
+			state.data.value = store.get(key) ?? (opts.default ? opts.default() : void 0);
+		});
+		return {
+			data: state.data,
+			error: state.error,
+			loading: state.loading,
+			refresh: execute,
+			invalidate
+		};
+	};
+}
+function invalidateCache(store, keyOrTag) {
+	return store.invalidate(keyOrTag);
+}
+function clearCache(store) {
+	store.clear();
+}
+function defineDataKey(key) {
+	return defineDataKey$1(key);
+}
+function createLinkHandler(ctx) {
+	return {
+		getProps: () => ({}),
+		async navigate(href, opts = {}) {
+			if (!ctx.__ubean_router) {
+				const loc = _global$1.location;
+				if (opts.replace) loc.replace(href);
+				else loc.href = href;
+				return;
+			}
+			if (opts.replace) await ctx.__ubean_router.replace(href);
+			else await ctx.__ubean_router.push(href);
+		},
+		async prefetch(_href) {}
+	};
+}
+function extractPageData() {
+	if (typeof _global$1.document === "undefined") return null;
+	const el = _global$1.document.getElementById("__UBEAN_PAGE_DATA__");
+	if (!el) return null;
+	try {
+		return JSON.parse(el.textContent || "null");
+	} catch {
+		return null;
+	}
+}
+async function useServerData(fetcher) {
+	return fetcher();
+}
+function getInvalidatedKeysForAction(actionName, invalidationMap, store) {
+	const toInvalidate = invalidationMap[actionName];
+	if (!toInvalidate) return 0;
+	let count = 0;
+	for (const key of toInvalidate) count += store.invalidate(key);
+	return count;
+}
+//#endregion
+//#region src/page-macro.ts
+function definePage(_meta) {}
+function defineMeta(_meta) {}
+function defineMiddleware(_handler) {}
+//#endregion
+//#region src/router-location.ts
+function resolveRoute(to, routeMap) {
+	if (typeof to === "string") {
+		if (to.startsWith("/") || to.startsWith("http") || to.startsWith("#")) return to;
+		return `/${to.replace(/^\//, "")}`;
+	}
+	let path = to.path || "/";
+	if (to.name && routeMap) {
+		const route = routeMap[to.name];
+		if (route) path = route.route;
+	}
+	if (to.params) for (const [key, value] of Object.entries(to.params)) path = path.replace(`:${key}`, String(value));
+	if (to.query) {
+		const qs = Object.entries(to.query).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
+		if (qs) path += (path.includes("?") ? "&" : "?") + qs;
+	}
+	if (to.hash) path += to.hash.startsWith("#") ? to.hash : `#${to.hash}`;
+	return path;
+}
+function isActiveRoute(currentPath, targetHref, exact = false) {
+	if (targetHref === "/" || targetHref === "") return currentPath === "/";
+	if (exact) return currentPath === targetHref || currentPath === `${targetHref}/`;
+	return currentPath === targetHref || currentPath.startsWith(`${targetHref}/`) || currentPath.startsWith(`${targetHref}?`);
+}
+//#endregion
+//#region src/islands.ts
+const _global = globalThis;
+function decodeProps(raw) {
+	if (!raw) return {};
+	try {
+		return JSON.parse(raw.replace(/&quot;/g, "\"").replace(/&amp;/g, "&").replace(/&lt;/g, "<"));
+	} catch {
+		return {};
+	}
+}
+function collectIslands(root) {
+	const doc = root ?? _global.document;
+	if (!doc) return [];
+	const nodes = doc.querySelectorAll("ubean-island[data-island-id]");
+	const records = [];
+	nodes.forEach((el) => {
+		const domEl = el;
+		const id = domEl.getAttribute("data-island-id") || "";
+		const componentName = domEl.getAttribute("data-component") || "";
+		const directive = domEl.getAttribute("data-directive") || "client:load";
+		const mediaQuery = domEl.getAttribute("data-media") || void 0;
+		const props = decodeProps(domEl.getAttribute("data-props"));
+		records.push({
+			el: domEl,
+			id,
+			componentName,
+			directive,
+			mediaQuery,
+			props
+		});
+	});
+	return records;
+}
+function hydrateIsland(record, component, options = {}) {
+	if (record.el.hasAttribute("data-hydrated")) return;
+	record.el.setAttribute("data-hydrated", "true");
+	const app = createApp(defineComponent({
+		name: `Island-${record.componentName}`,
+		setup() {
+			return () => h(component, record.props);
+		}
+	}));
+	if (options.appContext) {
+		if (options.appContext.config?.globalProperties) Object.assign(app.config.globalProperties, options.appContext.config.globalProperties);
+		const appContextInternal = options.appContext;
+		if (appContextInternal._context?.provides) for (const [key, value] of Object.entries(appContextInternal._context.provides)) app.provide(key, value);
+	}
+	app.mount(record.el);
+	options.onHydrated?.(record.el, component);
+}
+function hydrateIslands(options = {}) {
+	const { root, components = {}, getComponent, ...rest } = options;
+	const islands = collectIslands(root);
+	if (islands.length === 0) return;
+	for (const record of islands) {
+		if (record.directive === "client:only") {
+			const comp = resolveComponent(record.componentName, components, getComponent);
+			if (comp) Promise.resolve(comp).then((c) => hydrateIsland(record, c, rest));
+			continue;
+		}
+		const doHydrate = () => {
+			const comp = resolveComponent(record.componentName, components, getComponent);
+			if (comp) Promise.resolve(comp).then((c) => hydrateIsland(record, c, rest));
+		};
+		if (record.el.getAttribute("data-hydrating") === "true" && !record.el.hasAttribute("data-hydrated")) {
+			doHydrate();
+			continue;
+		}
+		const MutationObserverCtor = _global.MutationObserver ?? null;
+		if (MutationObserverCtor) {
+			const observer = new MutationObserverCtor(() => {
+				if (record.el.getAttribute("data-hydrating") === "true" && !record.el.hasAttribute("data-hydrated")) {
+					observer.disconnect();
+					doHydrate();
+				}
+			});
+			observer.observe(record.el, {
+				attributes: true,
+				attributeFilter: ["data-hydrating"]
+			});
+		}
+		const directive = record.directive;
+		if (directive === "client:load") doHydrate();
+		else if (directive === "client:idle") {
+			const ric = _global.requestIdleCallback;
+			if (typeof ric === "function") ric(() => doHydrate(), { timeout: 2e3 });
+			else setTimeout(doHydrate, 200);
+		} else if (directive === "client:visible") {
+			const IOCtor = _global.IntersectionObserver;
+			if (typeof IOCtor === "function") {
+				const io = new IOCtor((entries) => {
+					entries.forEach((entry) => {
+						if (entry.isIntersecting) {
+							io.disconnect();
+							doHydrate();
+						}
+					});
+				}, { rootMargin: "200px" });
+				io.observe(record.el);
+			} else doHydrate();
+		} else if (directive === "client:media" && record.mediaQuery) {
+			const mql = _global.window?.matchMedia?.(record.mediaQuery);
+			if (mql) if (mql.matches) doHydrate();
+			else {
+				const fn = (e) => {
+					if (e.matches) {
+						doHydrate();
+						if (mql.removeEventListener) mql.removeEventListener("change", fn);
+						else if (mql.removeListener) mql.removeListener(fn);
+					}
+				};
+				if (mql.addEventListener) mql.addEventListener("change", fn);
+				else if (mql.addListener) mql.addListener(fn);
+			}
+			else doHydrate();
+		} else doHydrate();
+	}
+}
+function resolveComponent(name, components, getComponent) {
+	if (components[name]) return components[name];
+	if (getComponent) return getComponent(name);
+	return null;
+}
+//#endregion
+export { Head, Link, PageView, addLocale, applyAppConfig, clearCache, clearLocales, clearPageTransition, collectIslands, createClientHead, createDataCacheStore, createDefaultAppConfig, createLinkHandler, createServerHead, createUbeanApp, createUbeanRouter, createUbeanSSRApp, createUseAsyncData, defineApp, defineDataKey, defineLocale, defineMeta, defineMiddleware, definePage, detectBrowserLocale, detectLocale, disablePageCache, enablePageCache, excludePageCache, extractLocaleFromPath, extractPageData, getCacheEnabled, getCachedViewNames, getDefaultLocale, getExcludedViewNames, getI18nConfig, getInitialPageData, getInvalidatedKeysForAction, getLocale, getLocaleDir, getLocaleName, getNavigationType, getPageTransitionName, getRegisteredLocales, getReloadCounter, hydrateIsland, hydrateIslands, includePageCache, initCachedViewsFromRoutes, injectHead, invalidateCache, invalidatePageCache, isActiveRoute, isCacheEnabled, isPageCached, isPageExcluded, isReloading, localizePath, mergeLocale, onLocaleChange, reloadPage, resetRouteCache, resolveRoute, setI18nConfig, setLocale, setPageTransition, supportsViewTransitions, switchLocalePath, t, useCacheViews, useUnheadHead as useHead, useHeadInstance, useI18n, useLocalePath, usePage, usePageTransition, useReloadSignal, useRouter, useSeoMeta, useServerData, useSwitchLocalePath, useViewTransition, useViewTransitionState, withViewTransition };

package/dist/view-transitions-DRrLaRHL.d.ts

@@ -0,0 +1,12 @@
+//#region src/view-transitions.d.ts
+interface ViewTransitionOptions {
+  enabled?: boolean;
+  fallback?: 'none' | 'crossfade';
+  types?: string[];
+}
+declare function supportsViewTransitions(): boolean;
+declare function withViewTransition<T>(callback: () => Promise<T> | T, options?: ViewTransitionOptions): Promise<T>;
+declare function getNavigationType(): 'traverse' | 'push' | 'replace' | 'reload';
+declare function useViewTransitionState(name: string): Record<string, string>;
+//#endregion
+export { withViewTransition as a, useViewTransitionState as i, getNavigationType as n, supportsViewTransitions as r, ViewTransitionOptions as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ubean/runtime",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Vue client runtime for ubean (createUbeanApp, useRouter, useHead, Link, Head, PageView, composables, view-transitions, cache-views, islands hydrate)",
   "files": [
     "dist"
@@ -27,9 +27,9 @@
     "@unhead/vue": "^3.2.3",
     "vue": "^3.5.40",
     "vue-router": "^5.2.0",
-    "@ubean/i18n": "0.1.1",
-    "@ubean/types": "0.1.1",
-    "@ubean/pages": "0.1.1"
+    "@ubean/pages": "0.1.3",
+    "@ubean/i18n": "0.1.3",
+    "@ubean/types": "0.1.3"
   },
   "devDependencies": {
     "@types/node": "^26.1.1",
@@ -37,8 +37,8 @@
     "vite-plus": "0.2.6"
   },
   "peerDependencies": {
-    "@ubean/routing": "0.1.1",
-    "@ubean/seo": "0.1.1"
+    "@ubean/routing": "0.1.3",
+    "@ubean/seo": "0.1.3"
   },
   "peerDependenciesMeta": {
     "@ubean/seo": {