@vizejs/musea-nuxt 0.0.1-alpha.92

package/dist/index.d.ts

@@ -0,0 +1,210 @@
+import { ref } from "vue";
+import { Plugin } from "vite";
+
+//#region src/types.d.ts
+/**
+* NuxtMusea plugin options.
+*/
+/**
+ * NuxtMusea plugin options.
+ */
+interface NuxtMuseaOptions {
+  /**
+   * Mock route data.
+   */
+  route?: {
+    path?: string;
+    name?: string;
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+    hash?: string;
+    fullPath?: string;
+    meta?: Record<string, unknown>;
+  };
+  /**
+   * Mock runtime config.
+   */
+  runtimeConfig?: {
+    public?: Record<string, unknown>;
+    [key: string]: unknown;
+  };
+  /**
+   * Mock useFetch / useAsyncData default responses.
+   * Key is the URL/key pattern, value is the mock response data.
+   */
+  fetchMocks?: Record<string, unknown>;
+  /**
+   * Mock useState initial values.
+   * Key is the state key, value is the initial state.
+   */
+  stateMocks?: Record<string, unknown>;
+} //#endregion
+//#region src/mocks/composables.d.ts
+/**
+ * Mock useRoute - returns a reactive route object.
+ */
+declare function useRoute(): any;
+/**
+ * Mock useRouter - returns a router-like object with no-op navigation.
+ */
+declare function useRouter(): {
+  push: (_to: unknown) => Promise<void>;
+  replace: (_to: unknown) => Promise<void>;
+  back: () => void;
+  forward: () => void;
+  go: (_delta: number) => void;
+  resolve: (to: unknown) => {
+    href: string;
+    route: any;
+  };
+  currentRoute: any;
+  addRoute: () => () => void;
+  removeRoute: () => void;
+  hasRoute: () => boolean;
+  getRoutes: () => never[];
+  beforeEach: () => () => void;
+  afterEach: () => () => void;
+  onError: () => () => void;
+  isReady: () => Promise<void>;
+  options: {};
+};
+//#endregion
+//#region src/mocks/data.d.ts
+interface AsyncDataResult<T> {
+  data: ReturnType<typeof ref<T | null>>;
+  pending: ReturnType<typeof ref<boolean>>;
+  error: ReturnType<typeof ref<Error | null>>;
+  refresh: () => Promise<void>;
+  execute: () => Promise<void>;
+  status: ReturnType<typeof ref<string>>;
+}
+/**
+ * Mock useFetch - returns reactive data based on mock config.
+ */
+declare function useFetch<T = unknown>(url: string | (() => string), _opts?: Record<string, unknown>): AsyncDataResult<T>;
+/**
+ * Mock useAsyncData - similar to useFetch but with key-based lookup.
+ */
+declare function useAsyncData<T = unknown>(key: string, _handler?: () => Promise<T>, _opts?: Record<string, unknown>): AsyncDataResult<T>;
+/**
+ * Mock useLazyFetch - lazy variant of useFetch.
+ */
+declare function useLazyFetch<T = unknown>(url: string | (() => string), opts?: Record<string, unknown>): AsyncDataResult<T>;
+/**
+ * Mock useLazyAsyncData - lazy variant of useAsyncData.
+ */
+declare function useLazyAsyncData<T = unknown>(key: string, handler?: () => Promise<T>, opts?: Record<string, unknown>): AsyncDataResult<T>;
+
+//#endregion
+//#region src/mocks/navigation.d.ts
+/**
+ * Mock Nuxt navigation utilities.
+ */
+/**
+ * Mock navigateTo - no-op in gallery context.
+ */
+declare function navigateTo(_to: string | Record<string, unknown>, _opts?: {
+  replace?: boolean;
+  redirectCode?: number;
+  external?: boolean;
+}): Promise<void>;
+/**
+ * Mock abortNavigation - no-op in gallery context.
+ */
+declare function abortNavigation(_err?: string | Error): void;
+
+//#endregion
+//#region src/mocks/head.d.ts
+/**
+ * Mock defineNuxtRouteMiddleware - returns the middleware function as-is.
+ */
+/**
+ * Mock Nuxt head management composables.
+ * All are no-ops in the gallery context.
+ */
+/**
+ * Mock useHead - no-op.
+ */
+declare function useHead(_input: Record<string, unknown>): void;
+/**
+ * Mock useSeoMeta - no-op.
+ */
+declare function useSeoMeta(_input: Record<string, unknown>): void;
+
+//#endregion
+//#region src/mocks/runtime.d.ts
+/**
+ * Mock useHeadSafe - no-op.
+ */
+/**
+ * Mock useNuxtApp - returns a minimal Nuxt app-like object.
+ */
+declare function useNuxtApp(): {
+  $config: any;
+  provide: (_name: string, _value: unknown) => void;
+  hook: (_name: string, _fn: (...args: unknown[]) => void) => void;
+  callHook: (_name: string, ..._args: unknown[]) => Promise<void>;
+  vueApp: null;
+  payload: any;
+  isHydrating: boolean;
+  runWithContext: <T>(fn: () => T) => T;
+};
+/**
+ * Mock useRuntimeConfig - returns the configured runtime config.
+ */
+declare function useRuntimeConfig(): any;
+/**
+ * Mock useState - returns a ref initialized from mock config or init function.
+ */
+declare function useState<T = unknown>(key: string, init?: () => T): any;
+/**
+ * Mock useRequestHeaders - returns empty headers in gallery context.
+ */
+
+/**
+ * Mock useCookie - returns a ref-like cookie mock.
+ */
+declare function useCookie<T = unknown>(name: string, _opts?: Record<string, unknown>): any;
+
+//#endregion
+//#region src/mocks/components.d.ts
+/**
+ * Mock clearNuxtState - no-op.
+ */
+/**
+ * Mock Nuxt built-in components.
+ */
+/**
+ * Mock NuxtLink - renders as <RouterLink> or <a>.
+ */
+declare const NuxtLink: any;
+/**
+ * Mock NuxtPage - renders <RouterView> or slot content.
+ */
+declare const NuxtPage: any;
+/**
+ * Mock ClientOnly - renders default slot on client side (always in browser context).
+ */
+declare const ClientOnly: any;
+/**
+ * Mock NuxtLayout - renders slot content with optional layout wrapper.
+ */
+declare const NuxtLayout: any;
+/**
+ * Mock NuxtLoadingIndicator - renders nothing.
+ */
+declare const NuxtLoadingIndicator: any;
+/**
+ * Mock NuxtErrorBoundary - renders default slot.
+ */
+declare const NuxtErrorBoundary: any;
+
+//#endregion
+//#region src/index.d.ts
+/**
+ * Create Nuxt mock Vite plugin for Musea.
+ */
+declare function nuxtMusea(options?: NuxtMuseaOptions): Plugin;
+
+//#endregion
+export { ClientOnly, NuxtErrorBoundary, NuxtLayout, NuxtLink, NuxtLoadingIndicator, NuxtMuseaOptions, NuxtPage, abortNavigation, navigateTo, nuxtMusea, useAsyncData, useCookie, useFetch, useHead, useLazyAsyncData, useLazyFetch, useNuxtApp, useRoute, useRouter, useRuntimeConfig, useSeoMeta, useState };

package/dist/index.js

@@ -0,0 +1,444 @@
+import { createRequire } from "module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { computed, defineComponent, h, reactive, ref } from "vue";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/plugin.ts
+const VIRTUAL_IMPORTS_ID = "\0musea-nuxt:imports";
+const VIRTUAL_IMPORTS_MODULE = "#imports";
+const VIRTUAL_NUXT_COMPONENTS_ID = "\0musea-nuxt:components";
+function createNuxtMuseaPlugin(options = {}) {
+	const srcDir = path.dirname(fileURLToPath(import.meta.url));
+	return {
+		name: "vite-plugin-musea-nuxt",
+		enforce: "pre",
+		config() {
+			return { resolve: { alias: {
+				"#imports": VIRTUAL_IMPORTS_MODULE,
+				"#app": VIRTUAL_IMPORTS_MODULE,
+				"#build": VIRTUAL_IMPORTS_MODULE
+			} } };
+		},
+		resolveId(id) {
+			if (id === VIRTUAL_IMPORTS_MODULE || id === "#imports" || id === "#app" || id === "#build") return VIRTUAL_IMPORTS_ID;
+			if (id === "#components" || id === "nuxt/dist/app/components") return VIRTUAL_NUXT_COMPONENTS_ID;
+			return null;
+		},
+		load(id) {
+			if (id === VIRTUAL_IMPORTS_ID) return generateImportsModule(srcDir, options);
+			if (id === VIRTUAL_NUXT_COMPONENTS_ID) return generateComponentsModule(srcDir);
+			return null;
+		},
+		transform(code, id) {
+			if (id.endsWith(".vue") || id.endsWith(".art.vue")) {
+				if (code.includes("<NuxtLink") || code.includes("<nuxt-link")) {
+					if (!code.includes("NuxtLink")) {
+						const importLine = `import { NuxtLink } from '${VIRTUAL_IMPORTS_MODULE}';\n`;
+						const lastImportIdx = code.lastIndexOf("import ");
+						if (lastImportIdx !== -1) {
+							const lineEnd = code.indexOf("\n", lastImportIdx);
+							code = code.slice(0, lineEnd + 1) + importLine + code.slice(lineEnd + 1);
+						}
+					}
+				}
+			}
+			return code;
+		}
+	};
+}
+function generateImportsModule(srcDir, options) {
+	const autoImportsPath = path.join(srcDir, "auto-imports.js").replace(/\\/g, "/");
+	const configJson = JSON.stringify(options);
+	return `
+// Auto-generated by @vizejs/musea-nuxt
+export * from '${autoImportsPath}';
+
+// Configure mocks with provided options
+import { _setRouteConfig } from '${path.join(srcDir, "mocks", "composables.js").replace(/\\/g, "/")}';
+import { _setFetchMocks } from '${path.join(srcDir, "mocks", "data.js").replace(/\\/g, "/")}';
+import { _setRuntimeConfig, _setStateMocks } from '${path.join(srcDir, "mocks", "runtime.js").replace(/\\/g, "/")}';
+
+const _config = ${configJson};
+_setRouteConfig(_config.route);
+_setFetchMocks(_config.fetchMocks ?? {});
+_setRuntimeConfig(_config.runtimeConfig);
+_setStateMocks(_config.stateMocks ?? {});
+`;
+}
+function generateComponentsModule(srcDir) {
+	const componentsPath = path.join(srcDir, "mocks", "components.js").replace(/\\/g, "/");
+	return `
+// Auto-generated by @vizejs/musea-nuxt
+export {
+  NuxtLink,
+  NuxtPage,
+  ClientOnly,
+  NuxtLayout,
+  NuxtLoadingIndicator,
+  NuxtErrorBoundary,
+} from '${componentsPath}';
+`;
+}
+
+//#endregion
+//#region src/mocks/composables.ts
+let _routeConfig = {};
+/**
+* Mock useRoute - returns a reactive route object.
+*/
+function useRoute() {
+	return reactive({
+		path: _routeConfig?.path ?? "/",
+		name: _routeConfig?.name ?? "index",
+		params: _routeConfig?.params ?? {},
+		query: _routeConfig?.query ?? {},
+		hash: _routeConfig?.hash ?? "",
+		fullPath: _routeConfig?.fullPath ?? _routeConfig?.path ?? "/",
+		meta: _routeConfig?.meta ?? {},
+		matched: [],
+		redirectedFrom: void 0
+	});
+}
+/**
+* Mock useRouter - returns a router-like object with no-op navigation.
+*/
+function useRouter() {
+	return {
+		push: async (_to) => {},
+		replace: async (_to) => {},
+		back: () => {},
+		forward: () => {},
+		go: (_delta) => {},
+		resolve: (to) => ({
+			href: typeof to === "string" ? to : "/",
+			route: useRoute()
+		}),
+		currentRoute: computed(() => useRoute()),
+		addRoute: () => () => {},
+		removeRoute: () => {},
+		hasRoute: () => false,
+		getRoutes: () => [],
+		beforeEach: () => () => {},
+		afterEach: () => () => {},
+		onError: () => () => {},
+		isReady: () => Promise.resolve(),
+		options: {}
+	};
+}
+
+//#endregion
+//#region src/mocks/data.ts
+let _fetchMocks = {};
+function findMockData(key) {
+	if (key in _fetchMocks) return _fetchMocks[key];
+	for (const [pattern, data] of Object.entries(_fetchMocks)) if (key.includes(pattern)) return data;
+	return void 0;
+}
+/**
+* Mock useFetch - returns reactive data based on mock config.
+*/
+function useFetch(url, _opts) {
+	const key = typeof url === "function" ? url() : url;
+	const mockData = findMockData(key);
+	const data = ref(mockData ?? null);
+	const pending = ref(false);
+	const error = ref(null);
+	const status = ref("success");
+	const refresh = async () => {};
+	const execute = async () => {};
+	return {
+		data,
+		pending,
+		error,
+		refresh,
+		execute,
+		status
+	};
+}
+/**
+* Mock useAsyncData - similar to useFetch but with key-based lookup.
+*/
+function useAsyncData(key, _handler, _opts) {
+	const mockData = findMockData(key);
+	const data = ref(mockData ?? null);
+	const pending = ref(false);
+	const error = ref(null);
+	const status = ref("success");
+	const refresh = async () => {};
+	const execute = async () => {};
+	return {
+		data,
+		pending,
+		error,
+		refresh,
+		execute,
+		status
+	};
+}
+/**
+* Mock useLazyFetch - lazy variant of useFetch.
+*/
+function useLazyFetch(url, opts) {
+	return useFetch(url, {
+		...opts,
+		lazy: true
+	});
+}
+/**
+* Mock useLazyAsyncData - lazy variant of useAsyncData.
+*/
+function useLazyAsyncData(key, handler, opts) {
+	return useAsyncData(key, handler, {
+		...opts,
+		lazy: true
+	});
+}
+
+//#endregion
+//#region src/mocks/navigation.ts
+/**
+* Mock Nuxt navigation utilities.
+*/
+/**
+* Mock navigateTo - no-op in gallery context.
+*/
+function navigateTo(_to, _opts) {
+	return Promise.resolve();
+}
+/**
+* Mock abortNavigation - no-op in gallery context.
+*/
+function abortNavigation(_err) {}
+
+//#endregion
+//#region src/mocks/head.ts
+/**
+* Mock Nuxt head management composables.
+* All are no-ops in the gallery context.
+*/
+/**
+* Mock useHead - no-op.
+*/
+function useHead(_input) {}
+/**
+* Mock useSeoMeta - no-op.
+*/
+function useSeoMeta(_input) {}
+
+//#endregion
+//#region src/mocks/runtime.ts
+let _runtimeConfig = {};
+let _stateMocks = {};
+/**
+* Mock useNuxtApp - returns a minimal Nuxt app-like object.
+*/
+function useNuxtApp() {
+	return {
+		$config: reactive({
+			public: _runtimeConfig?.public ?? {},
+			..._runtimeConfig
+		}),
+		provide: (_name, _value) => {},
+		hook: (_name, _fn) => {},
+		callHook: async (_name, ..._args) => {},
+		vueApp: null,
+		payload: reactive({
+			data: {},
+			state: {}
+		}),
+		isHydrating: false,
+		runWithContext: (fn) => fn()
+	};
+}
+/**
+* Mock useRuntimeConfig - returns the configured runtime config.
+*/
+function useRuntimeConfig() {
+	return reactive({
+		public: _runtimeConfig?.public ?? {},
+		..._runtimeConfig
+	});
+}
+/**
+* Mock useState - returns a ref initialized from mock config or init function.
+*/
+function useState(key, init) {
+	if (key in _stateMocks) return ref(_stateMocks[key]);
+	return ref(init ? init() : void 0);
+}
+/**
+* Mock useCookie - returns a ref-like cookie mock.
+*/
+function useCookie(name, _opts) {
+	const value = ref(void 0);
+	return value;
+}
+
+//#endregion
+//#region src/mocks/components.ts
+/**
+* Mock NuxtLink - renders as <RouterLink> or <a>.
+*/
+const NuxtLink = defineComponent({
+	name: "NuxtLink",
+	props: {
+		to: {
+			type: [String, Object],
+			default: "/"
+		},
+		href: {
+			type: String,
+			default: void 0
+		},
+		target: {
+			type: String,
+			default: void 0
+		},
+		rel: {
+			type: String,
+			default: void 0
+		},
+		external: {
+			type: Boolean,
+			default: false
+		},
+		replace: {
+			type: Boolean,
+			default: false
+		},
+		prefetch: {
+			type: Boolean,
+			default: true
+		},
+		noPrefetch: {
+			type: Boolean,
+			default: false
+		},
+		activeClass: {
+			type: String,
+			default: "router-link-active"
+		},
+		exactActiveClass: {
+			type: String,
+			default: "router-link-exact-active"
+		}
+	},
+	setup(props, { slots }) {
+		return () => {
+			const to = props.href || props.to;
+			if (props.external || typeof to === "string" && to.startsWith("http")) return h("a", {
+				href: typeof to === "string" ? to : "/",
+				target: props.target,
+				rel: props.rel ?? (props.target === "_blank" ? "noopener noreferrer" : void 0)
+			}, slots.default?.());
+			try {
+				const { RouterLink } = __require("vue-router");
+				return h(RouterLink, {
+					to,
+					replace: props.replace,
+					activeClass: props.activeClass,
+					exactActiveClass: props.exactActiveClass
+				}, slots);
+			} catch {
+				return h("a", { href: typeof to === "string" ? to : "/" }, slots.default?.());
+			}
+		};
+	}
+});
+/**
+* Mock NuxtPage - renders <RouterView> or slot content.
+*/
+const NuxtPage = defineComponent({
+	name: "NuxtPage",
+	props: {
+		name: {
+			type: String,
+			default: "default"
+		},
+		transition: {
+			type: [Boolean, Object],
+			default: void 0
+		},
+		keepalive: {
+			type: [Boolean, Object],
+			default: void 0
+		},
+		pageKey: {
+			type: [String, Function],
+			default: void 0
+		}
+	},
+	setup(props, { slots }) {
+		return () => {
+			if (slots.default) return slots.default();
+			try {
+				const { RouterView } = __require("vue-router");
+				return h(RouterView, { name: props.name });
+			} catch {
+				return h("div", { "data-nuxt-page": "" }, "NuxtPage placeholder");
+			}
+		};
+	}
+});
+/**
+* Mock ClientOnly - renders default slot on client side (always in browser context).
+*/
+const ClientOnly = defineComponent({
+	name: "ClientOnly",
+	setup(_props, { slots }) {
+		return () => slots.default?.() ?? null;
+	}
+});
+/**
+* Mock NuxtLayout - renders slot content with optional layout wrapper.
+*/
+const NuxtLayout = defineComponent({
+	name: "NuxtLayout",
+	props: {
+		name: {
+			type: String,
+			default: "default"
+		},
+		fallback: {
+			type: String,
+			default: void 0
+		}
+	},
+	setup(_props, { slots }) {
+		return () => slots.default?.() ?? null;
+	}
+});
+/**
+* Mock NuxtLoadingIndicator - renders nothing.
+*/
+const NuxtLoadingIndicator = defineComponent({
+	name: "NuxtLoadingIndicator",
+	render() {
+		return null;
+	}
+});
+/**
+* Mock NuxtErrorBoundary - renders default slot.
+*/
+const NuxtErrorBoundary = defineComponent({
+	name: "NuxtErrorBoundary",
+	setup(_props, { slots }) {
+		return () => slots.default?.() ?? null;
+	}
+});
+
+//#endregion
+//#region src/index.ts
+/**
+* Create Nuxt mock Vite plugin for Musea.
+*/
+function nuxtMusea(options = {}) {
+	return createNuxtMuseaPlugin(options);
+}
+
+//#endregion
+export { ClientOnly, NuxtErrorBoundary, NuxtLayout, NuxtLink, NuxtLoadingIndicator, NuxtPage, abortNavigation, navigateTo, nuxtMusea, useAsyncData, useCookie, useFetch, useHead, useLazyAsyncData, useLazyFetch, useNuxtApp, useRoute, useRouter, useRuntimeConfig, useSeoMeta, useState };

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@vizejs/musea-nuxt",
+  "version": "0.0.1-alpha.92",
+  "description": "Nuxt mock layer for Musea - enables Nuxt component isolation in galleries",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch"
+  },
+  "keywords": [
+    "nuxt",
+    "musea",
+    "vite-plugin",
+    "component-gallery",
+    "mock"
+  ],
+  "author": "ubugeeei",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ubugeeei/vize.git",
+    "directory": "npm/musea-nuxt"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "tsdown": "^0.9.0",
+    "typescript": "^5.7.0",
+    "vite": "^8.0.0-beta.0",
+    "vue": "^3.5.0",
+    "vue-router": "^4.5.0"
+  },
+  "peerDependencies": {
+    "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-beta.0",
+    "vue": "^3.5.0",
+    "vue-router": "^4.5.0"
+  },
+  "publishConfig": {
+    "provenance": true,
+    "access": "public"
+  }
+}