@mouseless/baked 1.5.3 → 1.6.1

package/dist/runtime/composables/useContext.d.ts

@@ -7,14 +7,28 @@ export default function _default(): {
     };
     injectDataDescriptor: () => null;
     provideDataDescriptor: (value: any) => void;
+    injectError: ({ handle }?: {
+        handle?: boolean | undefined;
+    }) => import("vue").Ref<{}, {}>;
+    provideError: (error: any) => import("vue").Ref<boolean, boolean>;
     injectEvents: () => any;
     provideEvents: (value: any) => void;
     injectExecuting: () => import("vue").Ref<boolean, boolean>;
     provideExecuting: (value: any) => void;
     injectLoading: () => import("vue").Ref<boolean, boolean>;
     provideLoading: (value: any) => void;
+    injectMutableValidations: () => {};
+    provideMutableValidations: (value: any) => void;
+    injectMutableValidation: () => null;
+    provideMutableValidation: (value: any) => void;
     injectPageContext: () => any;
     providePageContext: (value: any) => void;
     injectParentContext: () => null;
     provideParentContext: (value: any) => void;
+    injectValidations: () => null;
+    provideValidations: (value: any) => void;
+    injectValidation: () => null;
+    provideValidation: (value: any) => void;
+    injectValidationHandled: () => boolean;
+    provideValidationHandled: (value: any) => void;
 };

package/dist/runtime/composables/useContext.js

@@ -24,6 +24,29 @@ export default function() {
     return provide("__bake_data_descriptor", value);
   }
 
+  function injectError({ handle = false } = {}) {
+    const { error, handled } = inject("__bake_error", {
+      error: ref({}),
+      handled: ref(false)
+    });
+
+    if(handle) {
+      handled.value = true;
+    }
+
+    return error;
+  }
+
+  function provideError(error) {
+    const handled = ref(false);
+    provide("__bake_error", {
+      error,
+      handled
+    });
+
+    return handled;
+  }
+
   function injectEvents() {
     return inject("__bake_events");
   }
@@ -48,6 +71,22 @@ export default function() {
     provide("__bake_loading", value);
   }
 
+  function injectMutableValidations() {
+    return inject("__bake_mutable_validations", {});
+  }
+
+  function provideMutableValidations(value) {
+    provide("__bake_mutable_validations", value);
+  }
+
+  function injectMutableValidation() {
+    return inject("__bake_mutable_validation", null);
+  }
+
+  function provideMutableValidation(value) {
+    provide("__bake_mutable_validation", value);
+  }
+
   function injectPageContext() {
     return inject("__bake_page_context");
   }
@@ -64,21 +103,57 @@ export default function() {
     provide("__bake_parent_context", value);
   }
 
+  function injectValidations() {
+    return inject("__bake_validations", null);
+  }
+
+  function provideValidations(value) {
+    provide("__bake_validations", value);
+  }
+
+  function injectValidation() {
+    return inject("__bake_validation", null);
+  }
+
+  function provideValidation(value) {
+    provide("__bake_validation", value);
+  }
+
+  function injectValidationHandled() {
+    return inject("__bake_validation_handled", false);
+  }
+
+  function provideValidationHandled(value) {
+    provide("__bake_validation_handled", value);
+  }
+
   return {
     injectPath,
     providePath,
     injectContextData,
     injectDataDescriptor,
     provideDataDescriptor,
+    injectError,
+    provideError,
     injectEvents,
     provideEvents,
     injectExecuting,
     provideExecuting,
     injectLoading,
     provideLoading,
+    injectMutableValidations,
+    provideMutableValidations,
+    injectMutableValidation,
+    provideMutableValidation,
     injectPageContext,
     providePageContext,
     injectParentContext,
-    provideParentContext
+    provideParentContext,
+    injectValidations,
+    provideValidations,
+    injectValidation,
+    provideValidation,
+    injectValidationHandled,
+    provideValidationHandled
   };
-}
+}

package/dist/runtime/composables/useDataMounter.d.ts

@@ -1,5 +1,7 @@
-export default function _default(): {
-    mount: (schema: any) => import("vue").Ref<null, null>;
+export default function _default({ defaultInlineError }?: {}): {
+    mount: (schema: any, { inlineError }?: {
+        inlineError?: any;
+    }) => import("vue").Ref<null, null>;
     onAfterMount: (callback: any) => void;
     onBeforeMount: (callback: any) => void;
 };

package/dist/runtime/composables/useDataMounter.js

@@ -1,10 +1,13 @@
 import { onMounted, ref } from "vue";
 import { useContext, useDataFetcher } from "#imports";
 
-export default function() {
+export default function({ defaultInlineError } = {}) {
   const context = useContext();
   const dataFetcher = useDataFetcher();
+
   const contextData = context.injectContextData();
+  const error = context.injectError();
+
   const mounts = [];
   let onAfterMountCallback = null;
   let onBeforeMountCallback = null;
@@ -15,8 +18,14 @@ export default function() {
     }
 
     await Promise.all(
-      mounts.map(async({ value, schema }) => {
-        value.value = await dataFetcher.fetch({ data: schema, contextData });
+      mounts.map(async({ value, schema, inlineError }) => {
+        try {
+          value.value = await dataFetcher.fetch({ data: schema, contextData });
+        } catch (err) {
+          if(!inlineError || err.statusCode !== 400) { throw err; }
+
+          error.value = err;
+        }
       })
     );
 
@@ -25,7 +34,7 @@ export default function() {
     }
   });
 
-  function mount(schema) {
+  function mount(schema, { inlineError = defaultInlineError } = {}) {
     const value = ref(null);
 
     if(!schema) {
@@ -36,7 +45,7 @@ export default function() {
 
     const shouldLoad = dataFetcher.shouldLoad(schema);
     if(shouldLoad) {
-      mounts.push({ value, schema });
+      mounts.push({ value, schema, inlineError });
     }
 
     return value;
@@ -55,4 +64,4 @@ export default function() {
     onAfterMount,
     onBeforeMount
   };
-}
+}

package/dist/runtime/composables/useDefaultValidation.d.ts

@@ -0,0 +1,4 @@
+export default function useDefaultValidation({ inputs, model }: {
+    inputs: any;
+    model: any;
+}): {};

package/dist/runtime/composables/useDefaultValidation.js

@@ -0,0 +1,37 @@
+import { useLocalization } from "#imports";
+
+const capitalize = str => str.charAt(0).toUpperCase() + str.slice(1);
+
+export default function useDefaultValidation({ inputs, model }) {
+  const { localize: lc } = useLocalization({ group: "useDefaultValidation" });
+  const { localize: l } = useLocalization();
+
+  const result = {};
+  const validation = {
+    valid: false,
+    persist: false,
+    severity: "error",
+    message: ""
+  };
+
+  inputs.map(input => {
+    const value = model?.[input.name];
+    const isEmpty = value === undefined || value === null || String(value).trim() === "";
+    const label = input.component?.schema?.label?.text || capitalize(input.name);
+
+    result[input.name] = {
+      ...validation,
+      required: !!input.required,
+      valid: !input.required || !isEmpty,
+      persist: !(input.required && isEmpty)
+    };
+
+    if(input.required && isEmpty) {
+      result[input.name].message = lc("{label} cannot be empty", { label: l(label) });
+    }
+
+    return input;
+  });
+
+  return result;
+}

package/dist/runtime/composables/useRedirect.d.ts

@@ -1,3 +1,3 @@
 export default function _default(): {
-    run: ({ route, back, expected, actual }?: {}) => Promise<void>;
+    run: ({ route, back, expected, actual, ...params }?: {}) => Promise<void>;
 };

package/dist/runtime/composables/useRedirect.js

@@ -1,11 +1,17 @@
 import { useRouter } from "#app";
+import { usePathBuilder } from "#imports";
 
 export default function() {
   const router = useRouter();
+  const { build } = usePathBuilder();
 
-  async function run({ route, back, expected, actual } = {}) {
+  async function run({ route, back, expected, actual, ...params } = {}) {
     if(expected && actual !== expected) { return; }
 
+    if(route && Object.keys(params).length > 0) {
+      route = build(route, params, { forRoute: true });
+    }
+
     if(back) {
       router.back();
     } else {

package/dist/runtime/composables/useValidation.d.ts

@@ -0,0 +1,15 @@
+export default function _default(): {
+    validate: ({ model, inputs, composables }: {
+        model: any;
+        inputs: any;
+        composables?: never[] | undefined;
+    }) => {
+        isValid: import("vue").ComputedRef<boolean>;
+        messages: import("vue").ComputedRef<string>;
+        validations: import("vue").ComputedRef<any>;
+    };
+    injectMutable: () => {
+        clear: () => void;
+        setError: (message: any) => void;
+    } | null;
+};

package/dist/runtime/composables/useValidation.js

@@ -0,0 +1,79 @@
+import { computed } from "vue";
+import { useContext, useComposableResolver } from "#imports";
+
+export default function() {
+  const context = useContext();
+  const composableResolver = useComposableResolver();
+
+  function validate({ model, inputs, composables = [] }) {
+    const validationComposables = ["useDefaultValidation", ...composables.map(c => c.name)].map(vc => {
+      try {
+        return composableResolver.resolve(vc).default;
+      } catch {
+        console.error(`${vc} not loaded`);
+
+        return;
+      }
+    }).filter(v => v);
+
+    const validations = computed(() =>
+      validationComposables.reduce((acc, useComposable) => ({
+        ...acc,
+        ...useComposable({
+          inputs,
+          model: model.value
+        })
+      }), {})
+    );
+
+    const mutableValidations = {};
+
+    context.provideValidations(validations);
+    context.provideMutableValidations(mutableValidations);
+
+    const isValid = computed(() =>
+      Object.values(validations.value).every(v => v.valid) &&
+      Object.values(mutableValidations).every(v => v.value.valid)
+    );
+
+    const messages = computed(() =>
+      [...Object.values(validations.value), ...Object.values(mutableValidations).map(v => v.value)]
+        .filter(v => v.message)
+        .map((v, i) => `${i > 0 ? "\n" : ""} - ${v.message}`)
+        .join("")
+    );
+
+    return { isValid, messages, validations };
+  }
+
+  function injectMutable() {
+    const ref = context.injectMutableValidation();
+    if(!ref) { return null; }
+
+    return MutableValidation(ref);
+  }
+
+  return {
+    validate,
+    injectMutable
+  };
+}
+
+function MutableValidation(ref) {
+  function clear() {
+    ref.value.valid = true;
+    delete ref.value.message;
+    delete ref.value.severity;
+  }
+
+  function setError(message) {
+    ref.value.valid = false;
+    ref.value.message = message;
+    ref.value.severity = "error";
+  }
+
+  return {
+    clear,
+    setError
+  };
+}

package/dist/runtime/plugins/errorHandling.js

@@ -83,7 +83,7 @@ function getMessage(error) {
       severity: "error",
       summary: error.data?.title ?? error.statusCode ?? l($defaultAlert.title),
       detail: error.data?.detail ?? error.message ?? error.cause ?? l($defaultAlert.message),
-      life: 3000
+      wide: true
     };
   }
 
@@ -91,6 +91,6 @@ function getMessage(error) {
     severity: "error",
     summary: error.statusCode ?? error.status ?? l($defaultAlert.title),
     detail: error.message ?? error.cause ?? l($defaultAlert.message),
-    life: 3000
+    wide: true
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mouseless/baked",
-  "version": "1.5.3",
+  "version": "1.6.1",
   "description": "Baked is an opinionated framework for .NET and Vue. This is the UI package of Baked project.",
   "keywords": [
     "baked",
@@ -43,7 +43,7 @@
     "lint": "eslint ."
   },
   "dependencies": {
-    "@nuxtjs/i18n": "10.3.0",
+    "@nuxtjs/i18n": "10.4.0",
     "@nuxtjs/tailwindcss": "6.14.0",
     "@primeuix/themes": "2.0.3",
     "async-mutex": "0.5.0",
@@ -54,21 +54,21 @@
     "@nuxt/eslint": "1.15.2",
     "@nuxt/module-builder": "1.0.2",
     "@nuxt/test-utils": "4.0.3",
-    "@playwright/test": "1.59.1",
-    "@types/node": "25.6.0",
+    "@playwright/test": "1.60.0",
+    "@types/node": "25.9.1",
     "changelogen": "0.6.2",
-    "nuxt": "4.4.2",
-    "sass": "1.99.0",
+    "nuxt": "4.4.6",
+    "sass": "1.100.0",
     "typescript": "6.0.3",
-    "vitest": "4.1.5",
-    "vue-tsc": "3.2.8"
+    "vitest": "4.1.7",
+    "vue-tsc": "3.3.2"
   },
   "optionalDependencies": {
-    "@oxc-parser/binding-darwin-arm64": "0.129.0",
-    "@oxc-parser/binding-linux-arm64-gnu": "0.129.0",
-    "@oxc-parser/binding-linux-arm64-musl": "0.129.0",
-    "@oxc-parser/binding-linux-x64-gnu": "0.129.0",
-    "@oxc-parser/binding-linux-x64-musl": "0.129.0",
-    "@oxc-parser/binding-win32-x64-msvc": "0.129.0"
+    "@oxc-parser/binding-darwin-arm64": "0.133.0",
+    "@oxc-parser/binding-linux-arm64-gnu": "0.133.0",
+    "@oxc-parser/binding-linux-arm64-musl": "0.133.0",
+    "@oxc-parser/binding-linux-x64-gnu": "0.133.0",
+    "@oxc-parser/binding-linux-x64-musl": "0.133.0",
+    "@oxc-parser/binding-win32-x64-msvc": "0.133.0"
   }
 }