@dynamicforms/vue-forms 0.17.0 → 0.18.0

package/dist/index.d.ts

@@ -1,13 +1,16 @@
 import { ComponentOptionsMixin } from 'vue';
 import { ComponentProvideOptions } from 'vue';
+import { ComputedRef } from 'vue';
 import { DefineComponent } from 'vue';
 import { PublicProps } from 'vue';
 import { Ref } from 'vue';
+import { TranslateStringsCallback } from '@dynamicforms/translatable';
 
 /**
  * Thrown from a handler to end the run it is in. What the trigger answers with is the exception itself rather than
  * `null`, so a caller can tell a run a handler ended from one that reached no handler at all - and the setters
- * that ask a `*Changing*` handler read it as a refusal and write nothing.
+ * that ask a `*Changing*` handler read it as a refusal and write nothing. The answer carries it directly where the
+ * chain ran synchronously, and as what the answered promise resolves to where a handler in it was asynchronous.
  */
 export declare class AbortEventHandlingException extends Error {
 }
@@ -45,7 +48,8 @@ export declare class Action<T extends ActionValue = ActionValue, X extends objec
      *
      * The answer is a promise whatever the handler returns, so a handler that throws rejects it rather than throwing
      * out of this call: a caller that does not await the answer and does not attach a catch handler leaves that
-     * rejection unhandled.
+     * rejection unhandled. An `AbortEventHandlingException` is the one exception that does not reject: the answer
+     * resolves with it, in a synchronous chain as in an asynchronous one.
      */
     execute(params?: any): Promise<any>;
 }
@@ -103,10 +107,24 @@ export declare class ActionsMap {
     bindTo(owner: FieldBase): void;
     /** True where no eager action of `identifier` stands after `index`, which makes `index` the group's entry. */
     private static outermostEager;
+    /**
+     * True where `value` is a promise, which is what a walk through an asynchronous handler answers with. The test is
+     * the type rather than a `then` member: a handler may answer with a value object that carries one, and calling
+     * `then` on such an object replaces the answer with whatever that call returns.
+     */
+    private static isPromise;
+    /**
+     * Answers an abort with itself on the asynchronous path as well. Where a handler in the chain is asynchronous, the
+     * walk answers with a promise and the abort raised under it arrives as that promise's rejection; this turns it back
+     * into the value the caller receives, so a promise the trigger answers with resolves to the exception instead of
+     * rejecting with it. Anything else keeps rejecting.
+     */
+    private static answerAbort;
     /**
      * Enters a group at its outermost action. An abort ends the run and is answered with rather than raised: the
-     * exception is what the caller receives, so a run a handler ended is told apart from one that reached no handler
-     * and from one whose handler answered null.
+     * exception is what the caller receives - directly where the chain ran synchronously, as what the answered promise
+     * resolves to where it did not - so a run a handler ended is told apart from one that reached no handler and from
+     * one whose handler answered null.
      */
     private run;
     /**
@@ -139,11 +157,13 @@ export declare interface ActionValue {
 declare type AllowedValues<T> = T[] | Ref<T[]> | (() => T[]);
 
 /**
- * Depending on the useMarkdownInValidators setting, return either markdown or a plain string error message
+ * Depending on the useMarkdownInValidators setting, return either markdown or a plain string error message. A
+ * Ref is stripped/wrapped on read rather than once here, so a translated template re-applies the same choice
+ * as its text changes.
  * @param mdErrorString markdown source to optionally be stripped
- * @return MdString or string
+ * @return MdString or string, or a ComputedRef of either where `mdErrorString` is itself a Ref
  */
-export declare function buildErrorMessage(mdErrorString: string): string | MdString;
+export declare function buildErrorMessage<T extends string | Ref<string>>(mdErrorString: T): T extends Ref<string> ? ComputedRef<string | MdString> : string | MdString;
 
 export declare type ClassType = string | string[] | Record<string, boolean>;
 
@@ -984,6 +1004,9 @@ declare namespace Form {
         NullableList,
         Validators,
         buildErrorMessage,
+        translatedMessage,
+        strings,
+        translateStrings,
         isSimpleComponentDef,
         isCallableFunction,
         MdString,
@@ -1483,6 +1506,19 @@ export declare class Statement {
     collectFields(): Set<FieldBase>;
 }
 
+export declare const strings: {
+    Required: string;
+    MinValue: string;
+    MaxValue: string;
+    ValueInRange: string;
+    MinLength: string;
+    MaxLength: string;
+    LengthInRange: string;
+    Pattern: string;
+    InAllowedValues: string;
+    ValidationFailed: string;
+};
+
 declare class Transaction {
     private readonly participants;
     /** what a rollback has to put back beyond the state slots, newest last */
@@ -1593,6 +1629,22 @@ export declare interface TransactionControl {
     rollback(): never;
 }
 
+/** A built-in validator's default message, translated and reactive to a later `translateStrings` call. */
+export declare function translatedMessage(key: keyof typeof strings): ComputedRef<string | MdString>;
+
+export declare const translateStrings: (cb: TranslateStringsCallback<    {
+Required: string;
+MinValue: string;
+MaxValue: string;
+ValueInRange: string;
+MinLength: string;
+MaxLength: string;
+LengthInRange: string;
+Pattern: string;
+InAllowedValues: string;
+ValidationFailed: string;
+}>) => void;
+
 declare const TxAnnounceValue: unique symbol;
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dynamicforms/vue-forms",
   "private": false,
-  "version": "0.17.0",
+  "version": "0.18.0",
   "type": "module",
   "description": "A lightweight Vue.js library for form state management with built-in validation, conditional logic, nested structures, and a rich event system. UI-agnostic and TypeScript-first.",
   "author": "Jure Erzno\u017enik",
@@ -55,6 +55,7 @@
     "node": ">=22"
   },
   "dependencies": {
+    "@dynamicforms/translatable": "^0.1.0",
     "lodash-es": "^4.17.21"
   },
   "peerDependencies": {
@@ -68,7 +69,7 @@
     "@typescript-eslint/eslint-plugin": "^8.67.0",
     "@typescript-eslint/parser": "^8.67.0",
     "@vitejs/plugin-vue": "^6",
-    "@vitest/coverage-v8": "^3",
+    "@vitest/coverage-v8": "^4",
     "@vue/test-utils": "^2.2.4",
     "@vue/tsconfig": "^0.7.0",
     "baseline-browser-mapping": "^2.8.31",
@@ -85,10 +86,9 @@
     "prettier": "^3.9.6",
     "rollup-plugin-visualizer": "^5.14.0",
     "typescript": "^5",
-    "vite": "^7",
+    "vite": "^8",
     "vite-plugin-dts": "^4",
-    "vite-plugin-eslint": "^1.8.1",
-    "vitest": "^3",
+    "vitest": "^4",
     "vue-eslint-parser": "^10.4.1",
     "vue-markdown-render": "^2.3.0",
     "vue-tsc": "^2"