@mouseless/baked 0.19.0

package/dist/runtime/plugins/cacheUser.js

@@ -0,0 +1,37 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "#app";
+import { useCache, useToken } from "#imports";
+
+export default defineNuxtPlugin({
+  name: "cache-user",
+  enforce: "pre",
+  setup(nuxtApp) {
+    const { public: { cacheUser } } = useRuntimeConfig();
+    const { expirationInMinutes } = cacheUser;
+    const cache = useCache("cache:user", { expirationInMinutes });
+    const { $fetchInterceptors } = nuxtApp;
+
+    $fetchInterceptors.register(
+      "cache-user",
+      async({ request, options }, next) => {
+        if(options.attributes["client-cache"] !== "user") {
+          return await next();
+        }
+
+        const key = cache.buildKey({ path: request, query: options.query });
+        return await cache.getOrCreate({ key, create: next });
+      },
+      // should run before other interceptors
+      -10
+    );
+  },
+  hooks: {
+    "app:mounted"() {
+      const cache = useCache("cache:user");
+      const token = useToken();
+
+      token.onChanged(() => {
+        cache.clear();
+      });
+    }
+  }
+});

package/dist/runtime/plugins/errorHandling.d.ts

@@ -0,0 +1,14 @@
+declare const _default: import("#app").Plugin<{
+    errorHandlers: any;
+    defaultAlert: {
+        title: any;
+        message: any;
+    };
+}> & import("#app").ObjectPlugin<{
+    errorHandlers: any;
+    defaultAlert: {
+        title: any;
+        message: any;
+    };
+}>;
+export default _default;

package/dist/runtime/plugins/errorHandling.js

@@ -0,0 +1,96 @@
+import { defineNuxtPlugin, clearError, showError, useNuxtApp, useRuntimeConfig } from "#app";
+import { useDataFetcher, useLocalization, useToast } from "#imports";
+
+export default defineNuxtPlugin({
+  name: "errorHandling",
+  enforce: "pre",
+  async setup() {
+    const { public: { errorHandling } } = useRuntimeConfig();
+
+    const errorHandlers = errorHandling.handlers;
+    errorHandlers.sort((a,b) => a.order - b.order);
+
+    return {
+      provide: {
+        errorHandlers,
+        defaultAlert: {
+          title: errorHandling.defaultAlertTitle,
+          message: errorHandling.defaultAlertMessage
+        }
+      }
+    };
+  },
+  hooks: {
+    "vue:error": async error => {
+      const dataFetcher = useDataFetcher();
+      const { $errorHandlers, $router } = useNuxtApp();
+      const toast = useToast();
+
+      const handler = getHandler($errorHandlers, $router.currentRoute.value.fullPath, error);
+      if(!handler) {
+        showError(error);
+
+        return;
+      }
+
+      switch (handler.behavior) {
+      case "Alert":
+        await clearError(error);
+        toast.add(getMessage(error));
+        break;
+
+      case "Redirect":
+        await clearError(error);
+        toast.add(getMessage(error));
+        const redirectPath = await dataFetcher.fetch({ data: handler.behaviorArgument });
+        $router.replace(redirectPath);
+        break;
+
+      default:
+        if(error.name === "TypeError") {
+          error.statusCode = 999;
+        }
+        showError(error);
+      }
+    }
+  }
+});
+
+// handlers
+function getHandler(handlers, route, error) {
+  if(!handlers) {
+    return null;
+  }
+
+  for(const option of Object.values(handlers)) {
+    if(
+      (!option.statusCode || error.statusCode === option.statusCode) &&
+      (!option.routePattern || route.match(`/${option.routePattern}/`).length > 0)
+    ) {
+      return option;
+    }
+  }
+
+  return null;
+}
+
+function getMessage(error) {
+  const { $defaultAlert } = useNuxtApp();
+  const { localize: l } = useLocalization();
+
+  if(error.name === "FetchError") {
+    return {
+      severity: "error",
+      summary: error.data?.title ?? error.statusCode ?? l($defaultAlert.title),
+      detail: error.data?.detail ?? error.message ?? error.cause ?? l($defaultAlert.message),
+      life: 3000
+    };
+  }
+
+  return {
+    severity: "error",
+    summary: error.statusCode ?? error.status ?? l($defaultAlert.title),
+    detail: error.message ?? error.cause ?? l($defaultAlert.message),
+    life: 3000
+  };
+}

package/dist/runtime/plugins/fetch.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/fetch.js

@@ -0,0 +1,80 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "#app";
+import { ofetch } from "ofetch";
+
+export default defineNuxtPlugin({
+  name: "fetch-manager",
+  enforce: "pre",
+  setup(nuxtApp) {
+    const fetch = ofetch.create();
+    const interceptors = Interceptors();
+    const optionsTemplate = { headers: { }, query: { }, attributes: { } };
+
+    // register the actual fetch at the end of the interceptor pipeline
+    interceptors.register("actual-fetch",
+      async({ request, options }) => await fetch(request, options),
+      Number.MAX_SAFE_INTEGER
+    );
+
+    // wrap $fetch using interceptors to allow around interception
+    globalThis.$fetch = async(request, options) => {
+      // not all requests have headers, query, attributes objects. this might
+      // cause interceptors to fail. options template makes sure every
+      // request has those objects to be set to an empty object.
+      return await interceptors.execute({ request, options: { ...optionsTemplate, ...options } });
+    };
+
+    // Add to nuxtApp for access from plugins
+    nuxtApp.provide("fetchInterceptors", interceptors);
+  }
+});
+
+function Interceptors() {
+  const { public: { composables } } = useRuntimeConfig();
+  const interceptorMap = new Map();
+
+  let interceptors = null;
+  let sorted = false;
+
+  function register(name, execute,
+    priority = 0
+  ) {
+    interceptorMap.set(name, { execute, priority });
+    sorted = false;
+  }
+
+  function ensureSorted() {
+    if(sorted && interceptors) { return; }
+
+    interceptors = Array.from(interceptorMap.entries())
+      .sort(([, a], [, b]) => a.priority - b.priority)
+      .map(([, interceptor]) => interceptor);
+    sorted = true;
+  }
+
+  async function execute(context) {
+    ensureSorted();
+
+    // doesn't intercept `/_nuxt` calls and any other non api calls
+    if(context.options.baseURL !== composables.useDataFetcher.baseURL) {
+      // directly executes last interceptor which is the actual fetch
+      return await executeInner(context, interceptors.length - 1);
+    }
+
+    return await executeInner(context, 0);
+  }
+
+  async function executeInner(context, index) {
+    if(index >= interceptors.length) { return; }
+
+    const interceptor = interceptors[index];
+
+    return await interceptor.execute(context, async() => {
+      return await executeInner(context, index + 1);
+    });
+  }
+
+  return {
+    register,
+    execute
+  };
+};

package/dist/runtime/plugins/localization.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/localization.js

@@ -0,0 +1,18 @@
+import { defineNuxtPlugin } from "#app";
+
+export default defineNuxtPlugin({
+  name: "localization",
+  enforce: "pre",
+  setup(nuxtApp) {
+    const { $fetchInterceptors } = nuxtApp;
+
+    $fetchInterceptors.register(
+      "localization",
+      async({ options }, next) => {
+        options.headers["Accept-Language"] = nuxtApp.$i18n.locale.value;
+
+        return await next();
+      }
+    );
+  }
+});

package/dist/runtime/plugins/mutex.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("#app").Plugin<{
+    mutex: Mutex;
+}> & import("#app").ObjectPlugin<{
+    mutex: Mutex;
+}>;
+export default _default;
+import { Mutex } from "async-mutex";

package/dist/runtime/plugins/mutex.js

@@ -0,0 +1,15 @@
+import { defineNuxtPlugin } from "#app";
+import { Mutex } from "async-mutex";
+
+export default defineNuxtPlugin({
+  name: "mutex",
+  setup() {
+    const mutex = new Mutex();
+
+    return {
+      provide: {
+        mutex
+      }
+    };
+  }
+});

package/dist/runtime/plugins/primeVue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/primeVue.js

@@ -0,0 +1,75 @@
+import PrimeVue, { usePrimeVue } from "primevue/config";
+import FocusTrap from "primevue/focustrap";
+import Tooltip from "primevue/tooltip";
+import { defineNuxtPlugin, useNuxtApp, useRouter, useRuntimeConfig } from "#app";
+import { ref } from "vue";
+
+export default defineNuxtPlugin({
+  name: "primeVue",
+  setup(nuxtApp) {
+    const router = useRouter();
+    const { public: { primevue: { theme, locale } } } = useRuntimeConfig();
+    const shouldLoadLocale = ref(true);
+
+    const options = {
+      theme: {
+        preset: theme,
+        options: {
+          cssLayer: {
+            name: "primevue",
+            order: "tailwind-base, primevue, tailwind-utilities"
+          }
+        }
+      }
+    };
+
+    if(locale) { options.locale = locale; }
+
+    nuxtApp.vueApp.use(PrimeVue, options);
+    nuxtApp.vueApp.directive("focustrap", FocusTrap);
+    nuxtApp.vueApp.directive("tooltip", Tooltip);
+
+    router.beforeEach(() => {
+      if(!shouldLoadLocale.value) {
+        return;
+      }
+
+      if(!nuxtApp.$i18n) {
+        shouldLoadLocale.value = false;
+        return;
+      }
+
+      loadPrimeVueMessages();
+      shouldLoadLocale.value = false;
+    });
+  }
+});
+
+function loadPrimeVueMessages() {
+  const { $i18n } = useNuxtApp();
+  const primevue = usePrimeVue();
+
+  const raw = $i18n.tm("primevue");
+  const primevueMessages = {};
+
+  for(const key in raw) {
+    primevueMessages[key] = extractText(raw[key]);
+  }
+
+  primevue.config.locale = { ...primevue.config.locale, ...primevueMessages };
+}
+
+function extractText(val) {
+  if(typeof val === "string") { return val; }
+
+  if(Array.isArray(val)) {
+    return [...val.map(extractText)];
+  }
+
+  if(typeof val === "object") {
+    // 'val.b?.s' is for playwright
+    return val.loc?.source || val.b?.s || val.value || extractText(val.body || "") || "";
+  }
+
+  return "";
+}

package/dist/runtime/plugins/toast.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("#app").Plugin<{
+    toast: import("primevue").ToastServiceMethods;
+}> & import("#app").ObjectPlugin<{
+    toast: import("primevue").ToastServiceMethods;
+}>;
+export default _default;

package/dist/runtime/plugins/toast.js

@@ -0,0 +1,18 @@
+import { defineNuxtPlugin } from "#app";
+import { useToast } from "primevue/usetoast";
+import ToastService from "primevue/toastservice";
+
+export default defineNuxtPlugin({
+  name: "toast",
+  enforce: "pre",
+  setup(_nuxtApp) {
+    _nuxtApp.vueApp.use(ToastService);
+    const toast = useToast();
+
+    return {
+      provide: {
+        toast
+      }
+    };
+  }
+});

package/dist/runtime/plugins/trailingSlash.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/trailingSlash.js

@@ -0,0 +1,18 @@
+import { defineNuxtPlugin } from "#app";
+
+export default defineNuxtPlugin({
+  name: "trailingSlash",
+  enforce: "pre",
+  setup(nuxtApp) {
+    const router = nuxtApp.$router;
+
+    router.beforeEach(async to => {
+      if(to.path !== "/" && to.path.endsWith("/")) {
+        await router.replace({
+          path: to.path.slice(0, -1),
+          query: to.query
+        });
+      }
+    });
+  }
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type Components, type Composables, type ModuleOptions, type PageOptions, type PrimeVueOptions, type RetryOptions, type ScreenOptions, type UseBreakpointsOptions, type UseDataFetcherOptions, type UseFormatOptions } from './module.mjs'

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@mouseless/baked",
+  "version": "0.19.0",
+  "description": "Baked is an opinionated framework for .NET and Vue. This is the UI package of Baked project.",
+  "keywords": [
+    "baked",
+    "ui"
+  ],
+  "homepage": "https://baked.mouseless.codes",
+  "bugs": {
+    "url": "https://matrix.to/#/#baked:mouseless.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mouseless/baked.git"
+  },
+  "license": "MIT",
+  "author": "mouseless",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepack": "nuxt-module-build build",
+    "postinstall": "nuxt prepare",
+    "build": "npm run lint && nuxt-module-build build --stub && nuxt-module-build prepare",
+    "dev": "npm run lint && nuxi dev playground --dotenv .env.development --host",
+    "test": "playwright test",
+    "lint": "eslint ."
+  },
+  "dependencies": {
+    "@nuxtjs/i18n": "10.1.1",
+    "@nuxtjs/tailwindcss": "6.14.0",
+    "@primeuix/themes": "1.2.5",
+    "async-mutex": "0.5.0",
+    "primeicons": "7.0.0",
+    "primevue": "4.4.1"
+  },
+  "devDependencies": {
+    "@nuxt/eslint": "1.9.0",
+    "@nuxt/module-builder": "1.0.2",
+    "@nuxt/test-utils": "3.19.2",
+    "@playwright/test": "1.56.1",
+    "@types/node": "24.8.1",
+    "changelogen": "0.6.2",
+    "nuxt": "4.1.3",
+    "sass": "1.93.2",
+    "typescript": "5.9.3",
+    "vitest": "3.2.4",
+    "vue-tsc": "3.1.1"
+  },
+  "optionalDependencies": {
+    "@oxc-parser/binding-darwin-arm64": "0.95.0",
+    "@oxc-parser/binding-linux-arm64-gnu": "0.95.0",
+    "@oxc-parser/binding-linux-arm64-musl": "0.95.0",
+    "@oxc-parser/binding-linux-x64-gnu": "0.95.0",
+    "@oxc-parser/binding-linux-x64-musl": "0.95.0",
+    "@oxc-parser/binding-win32-x64-msvc": "0.95.0"
+  }
+}