@nexterajs/ui 0.0.1 → 0.1.0

package/types/nexterajs-ui-validation.d.ts

@@ -1,11 +1,13 @@
 import * as _angular_core from '@angular/core';
-import { NxeValidationResult } from '@nexterajs/ui/core';
+import { NxeMessageService, NxeValidatedEvent, NxeBrokenRule, NxeValidationResult } from '@nexterajs/ui/core';
 import { ValidatorFn } from '@angular/forms';
 
 /** DevExtreme validation rule type (the codebase uses `required`, `compare`, and `range`). */
 type NxeValidationRuleType = 'required' | 'compare' | 'custom' | 'pattern' | 'email' | 'range';
 /**
- * The message shown when a rule fails and the caller gave none.
+ * The English message shown when a rule fails and the caller gave none. The components resolve it
+ * through `NxeMessageService` (`validation.rule.*`), which starts as these same strings and
+ * follows the active language; this table stays for code that reads it directly.
  *
  * These are DevExtreme's own defaults, verbatim from its `validation-*` message keys. Without
  * them a rule with no `message` blocks its group and displays nothing at all, because every
@@ -15,8 +17,35 @@ declare const NXE_DEFAULT_VALIDATION_MESSAGES: Readonly<Record<NxeValidationRule
 /** Payload passed to a `custom` rule's `validationCallback` (mirrors DevExtreme). */
 interface NxeCustomRuleData {
     value: unknown;
-    rule: NxeValidationRuleComponent;
+    /** Absent when the rule came from `[validationRules]` rather than a projected element. */
+    rule?: NxeValidationRuleComponent;
 }
+/**
+ * A rule as plain data.
+ *
+ * The projected `<nxe-validation-rule>` and the `[validationRules]` array are two ways of saying
+ * the same thing, so they evaluate through one function rather than two implementations that
+ * could drift.
+ */
+interface NxeRuleSpec {
+    type: NxeValidationRuleType;
+    message?: string;
+    comparisonTarget?: () => unknown;
+    comparisonType?: '==' | '===' | '!=' | '!==' | '>' | '<' | '>=' | '<=';
+    validationCallback?: (data: NxeCustomRuleData) => boolean;
+    pattern?: string | RegExp;
+    min?: number;
+    max?: number;
+}
+/** DevExtreme RequiredRule semantics: null/undefined/''/false are "not specified". */
+declare function nxeIsEmptyValue(value: unknown): boolean;
+/**
+ * The message for a rule with none of its own: the active language's when a message service is
+ * given, English otherwise.
+ */
+declare function nxeDefaultMessage(type: NxeValidationRuleType, messages?: NxeMessageService): string;
+/** Whether `value` satisfies `spec`. The single evaluator behind both rule forms. */
+declare function nxeEvaluateRule(spec: NxeRuleSpec, value: unknown, rule?: NxeValidationRuleComponent): boolean;
 /**
  * `nxe-validation-rule` — drop-in for DevExtreme `dxi-validation-rule`.
  *
@@ -25,31 +54,29 @@ interface NxeCustomRuleData {
  * `type` input covers 100% of usage.
  */
 declare class NxeValidationRuleComponent {
+    private readonly messages;
     readonly type: _angular_core.InputSignal<NxeValidationRuleType>;
     readonly message: _angular_core.InputSignal<string>;
     /** `compare` rule: returns the value to compare against. Mirrors `comparisonTarget`. */
-    readonly comparisonTarget: _angular_core.InputSignal<() => unknown>;
+    readonly comparisonTarget: _angular_core.InputSignal<(() => unknown) | undefined>;
     /** `compare` rule comparison operator (default `==`). */
     readonly comparisonType: _angular_core.InputSignal<"==" | "===" | "!=" | "!==" | ">" | "<" | ">=" | "<=">;
     /** `custom` rule: returns true when valid. Mirrors `validationCallback`. */
-    readonly validationCallback: _angular_core.InputSignal<(data: NxeCustomRuleData) => boolean>;
+    readonly validationCallback: _angular_core.InputSignal<((data: NxeCustomRuleData) => boolean) | undefined>;
     /** `pattern` rule. */
-    readonly pattern: _angular_core.InputSignal<string | RegExp>;
+    readonly pattern: _angular_core.InputSignal<string | RegExp | undefined>;
     /** `range` rule bounds (DevExtreme RangeRule: empty values pass, bounds are inclusive). */
-    readonly min: _angular_core.InputSignal<number>;
-    readonly max: _angular_core.InputSignal<number>;
+    readonly min: _angular_core.InputSignal<number | undefined>;
+    readonly max: _angular_core.InputSignal<number | undefined>;
     /**
      * The message to show when this rule fails: the caller's, or DevExtreme's default for the
      * rule type. Whitespace counts as absent — a message of spaces is still an empty bubble.
      */
     readonly resolvedMessage: _angular_core.Signal<string>;
+    /** This rule as plain data, so both rule forms evaluate through one function. */
+    toSpec(): NxeRuleSpec;
     /** Whether `value` satisfies this rule. */
     evaluate(value: unknown): boolean;
-    /** DevExtreme RequiredRule semantics: null/undefined/''/false are "not specified". */
-    private isEmpty;
-    private compare;
-    private inRange;
-    private matchesPattern;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeValidationRuleComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeValidationRuleComponent, "nxe-validation-rule", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "comparisonTarget": { "alias": "comparisonTarget"; "required": false; "isSignal": true; }; "comparisonType": { "alias": "comparisonType"; "required": false; "isSignal": true; }; "validationCallback": { "alias": "validationCallback"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -58,28 +85,61 @@ declare class NxeValidationRuleComponent {
  * `nxe-validator` — drop-in for DevExtreme `dx-validator`.
  *
  * Placed inside an editor (`<nxe-text-box><nxe-validator><nxe-validation-rule .../></nxe-validator></nxe-text-box>`),
- * it adapts the editor via {@link NXE_VALIDATION_TARGET}, collects its `nxe-validation-rule`
- * children, and registers into the {@link NxeValidationGroupRegistry} under the editor's
- * `validationGroup`. Validation is on-demand (matching DevExtreme: not auto-run on change) —
- * `validate()` is invoked by `nxe-button[validationGroup]` (group-level) or directly.
+ * it adapts the editor via {@link NXE_VALIDATION_TARGET}, collects its rules, and registers into
+ * the {@link NxeValidationGroupRegistry} under the editor's `validationGroup`.
+ *
+ * Validation is on demand, as in DevExtreme — `validate()` is invoked by
+ * `nxe-button[validationGroup]` or directly. With one exception, which is also dx's: once a
+ * validator HAS been validated, it re-validates as the value changes, so a field that has gone
+ * red clears itself as the user fixes it rather than staying red until the next submit.
  */
 declare class NxeValidatorComponent {
     private readonly target;
     private readonly registry;
+    private readonly messages;
+    private readonly groupScope;
     readonly rules: _angular_core.Signal<readonly NxeValidationRuleComponent[]>;
+    /**
+     * dx `validationRules` — rules as data instead of projected children. Both forms combine;
+     * projected children come first, matching declaration order.
+     */
+    readonly validationRules: _angular_core.InputSignal<readonly NxeRuleSpec[] | undefined>;
     /** Explicit group; otherwise inherited from the wrapped editor's `validationGroup`. */
-    readonly validationGroupInput: _angular_core.InputSignal<string>;
+    readonly validationGroupInput: _angular_core.InputSignal<string | undefined>;
+    /** dx `onValidated`, fired on every validation, valid or not. */
+    readonly onValidated: _angular_core.OutputEmitterRef<NxeValidatedEvent>;
     private readonly group;
     /** Last validation outcome (false once a rule has failed, until re-validated). */
     readonly isValid: _angular_core.WritableSignal<boolean>;
+    /** Every rule broken by the last validation, in declaration order. */
+    readonly brokenRules: _angular_core.WritableSignal<readonly NxeBrokenRule[]>;
+    /** Whether `validate()` has ever run — the gate on live re-validation. */
+    private readonly validated;
     /** DevExtreme parity: existing code calls `validator.instance.validate()` via `@ViewChild`. */
     get instance(): NxeValidatorComponent;
     private readonly member;
+    /** Projected children plus `[validationRules]`, as one evaluable list. */
+    private readonly allRules;
     constructor();
-    /** Run all rules against the editor's current value; pushes the first failing message. */
+    /** Re-word the broken rules after a language switch, without validating again or emitting. */
+    private refreshMessages;
+    /**
+     * Run every rule against the editor's current value.
+     *
+     * dx reports ALL broken rules, not just the first — a `brokenRules` array with at most one
+     * entry cannot tell a caller whether a field failed once or three times. The editor's bubble
+     * still shows the first message, which is what dx renders.
+     */
     validate(): NxeValidationResult;
+    /**
+     * Clear the error state without validating (dx `reset()`).
+     *
+     * Also clears `validated`, so the field goes back to staying quiet until it is validated
+     * again — otherwise a reset field would light up on the next keystroke.
+     */
+    reset(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeValidatorComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeValidatorComponent, "nxe-validator", never, { "validationGroupInput": { "alias": "validationGroup"; "required": false; "isSignal": true; }; }, {}, ["rules"], ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeValidatorComponent, "nxe-validator", never, { "validationRules": { "alias": "validationRules"; "required": false; "isSignal": true; }; "validationGroupInput": { "alias": "validationGroup"; "required": false; "isSignal": true; }; }, { "onValidated": "onValidated"; }, ["rules"], ["*"], true, never>;
 }
 
 declare class NxeValidators {
@@ -98,5 +158,33 @@ declare class NxeValidators {
     static mustMatch(controlPath: string, matchingControlPath: string): ValidatorFn;
 }
 
-export { NXE_DEFAULT_VALIDATION_MESSAGES, NxeValidationRuleComponent, NxeValidatorComponent, NxeValidators };
-export type { NxeCustomRuleData, NxeValidationRuleType };
+/**
+ * `nxe-validation-group` — drop-in for DevExtreme `dx-validation-group`.
+ *
+ * DevExtreme lets a group be addressed two ways. Either a string name is repeated on the
+ * validator and on the button, or both are wrapped in a group element and the relationship is
+ * structural. Only the string form existed here, which meant a form could not be validated as a
+ * unit without inventing a name for it and keeping that name in two places.
+ *
+ * The key is generated, not derived from anything the application controls, so two groups on one
+ * page cannot collide and a group can never accidentally share a name with a string group. An
+ * explicit `validationGroup` on a descendant still wins, as in dx — the structural form is a
+ * default, not an override.
+ */
+declare class NxeValidationGroupComponent {
+    private readonly registry;
+    private readonly scope;
+    /** The generated key descendants register under. Exposed for a caller that needs to name it. */
+    get groupKey(): string;
+    /** DevExtreme parity: `group.instance.validate()` / `.reset()`. */
+    get instance(): NxeValidationGroupComponent;
+    /** Validate every validator inside this group. */
+    validate(): NxeValidationResult;
+    /** Clear every validator inside this group without validating (dx `reset()`). */
+    reset(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeValidationGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeValidationGroupComponent, "nxe-validation-group", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { NXE_DEFAULT_VALIDATION_MESSAGES, NxeValidationGroupComponent, NxeValidationRuleComponent, NxeValidatorComponent, NxeValidators, nxeDefaultMessage, nxeEvaluateRule, nxeIsEmptyValue };
+export type { NxeCustomRuleData, NxeRuleSpec, NxeValidationRuleType };

package/types/nexterajs-ui.d.ts

@@ -1,12 +1,18 @@
 export * from '@nexterajs/ui/animations';
+export * from '@nexterajs/ui/charts';
 export * from '@nexterajs/ui/core';
+export * from '@nexterajs/ui/display';
 export * from '@nexterajs/ui/dropdowns';
 export * from '@nexterajs/ui/excel';
 export * from '@nexterajs/ui/file-uploader';
 export * from '@nexterajs/ui/forms';
 export * from '@nexterajs/ui/grid';
 export * from '@nexterajs/ui/intl';
+export * from '@nexterajs/ui/navigation';
+export * from '@nexterajs/ui/notify';
+export * from '@nexterajs/ui/overlay';
 export * from '@nexterajs/ui/pivot';
+export * from '@nexterajs/ui/shell';
 export * from '@nexterajs/ui/styling';
 export * from '@nexterajs/ui/tree-view';
 export * from '@nexterajs/ui/validation';