@alfadocs/ui-kit 0.7.2 → 0.8.0

package/dist/_chunks/use-password-requirements-DgEYdN4H.js

@@ -0,0 +1,446 @@
+import { jsxs as g, jsx as a } from "react/jsx-runtime";
+import { forwardRef as ts, useRef as as, useState as C, useEffect as is, useCallback as u, useMemo as V } from "react";
+import { c as L } from "./index-D2ZczOXr.js";
+import { useTranslation as W } from "react-i18next";
+import { T as rs } from "./text-input-DZwt9L8H.js";
+import { u as ns } from "./form-field-context-B3APVHKx.js";
+import { c as os } from "./compose-refs-C0k0tdqF.js";
+import { u as ds } from "./registry-C9nwlNyL.js";
+import { E as ls } from "./eye-off-xEXDAh5z.js";
+import { c as cs } from "./createLucideIcon-CrFbzy84.js";
+import { C as us } from "./check-DPdL_Sm7.js";
+import { C as ps } from "./circle-BkqTgYmt.js";
+import { T as ms } from "./triangle-alert-CBPUIzQo.js";
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const fs = [
+  [
+    "path",
+    {
+      d: "M2.062 12.348a1 1 0 0 1 0-.696 10.75 10.75 0 0 1 19.876 0 1 1 0 0 1 0 .696 10.75 10.75 0 0 1-19.876 0",
+      key: "1nclc0"
+    }
+  ],
+  ["circle", { cx: "12", cy: "12", r: "3", key: "1v7zrd" }]
+], gs = cs("eye", fs), hs = {
+  id: "password-input",
+  capabilities: ["edit_inline"],
+  state: {
+    value: {
+      type: "string",
+      descriptionKey: "ui.agent.passwordInput.state.value",
+      description: "Current password value. Never log or persist this off-device.",
+      read: (e) => e.getValue()
+    },
+    isEmpty: {
+      type: "boolean",
+      descriptionKey: "ui.agent.passwordInput.state.isEmpty",
+      description: "Whether the input has no value.",
+      read: (e) => e.getValue() === ""
+    },
+    isRevealed: {
+      type: "boolean",
+      descriptionKey: "ui.agent.passwordInput.state.isRevealed",
+      description: "Whether the password is currently shown in plain text.",
+      read: (e) => e.isRevealed()
+    }
+  },
+  actions: {
+    set_value: {
+      safety: "write",
+      argsType: "{ value: string }",
+      descriptionKey: "ui.agent.passwordInput.actions.setValue",
+      description: "Replace the password value.",
+      invoke: (e, r) => {
+        e.setValue(r.value);
+      }
+    },
+    clear: {
+      safety: "destructive",
+      descriptionKey: "ui.agent.passwordInput.actions.clear",
+      description: "Empty the input. Loses any typed value.",
+      invoke: (e) => {
+        e.clear();
+      }
+    },
+    focus: {
+      safety: "read",
+      descriptionKey: "ui.agent.passwordInput.actions.focus",
+      description: "Move keyboard focus to the input.",
+      invoke: (e) => {
+        e.focus();
+      }
+    },
+    toggle_visibility: {
+      safety: "read",
+      descriptionKey: "ui.agent.passwordInput.actions.toggleVisibility",
+      description: "Toggle between masked and plain-text display.",
+      invoke: (e) => {
+        e.toggleVisibility();
+      }
+    }
+  },
+  domHooks: {
+    root: {
+      attr: "data-component",
+      value: "password-input",
+      description: "Marks the PasswordInput wrapper."
+    },
+    instanceId: {
+      attr: "data-component-id",
+      sourceProp: "id",
+      description: "Sourced from the id prop."
+    }
+  }
+}, ws = {
+  sm: "ds:size-4",
+  md: "ds:size-[18px]",
+  lg: "ds:size-5"
+}, bs = L(
+  [
+    "ds:absolute ds:inset-y-0 ds:end-0 ds:ps-2 ds:pe-3",
+    "ds:inline-flex ds:items-center ds:justify-center",
+    "ds:text-muted-foreground ds:hover:text-foreground",
+    "ds:bg-transparent ds:border-0 ds:cursor-pointer",
+    "ds:rounded-[var(--radius-sm)]",
+    "ds:min-w-[var(--min-target-size)]",
+    "ds:transition-colors ds:duration-[var(--animation-duration)] ds:motion-reduce:transition-none",
+    "ds:focus-visible:outline-[length:var(--focus-ring-width)] ds:focus-visible:outline-solid",
+    "ds:focus-visible:outline-ring ds:focus-visible:outline-offset-[length:var(--focus-ring-offset)]",
+    "ds:forced-colors:focus-visible:outline-[CanvasText]",
+    "ds:disabled:cursor-not-allowed ds:disabled:opacity-50"
+  ].join(" ")
+), vs = L(
+  "ds:h-1 ds:w-full ds:overflow-hidden ds:rounded-[var(--radius-full)] ds:bg-muted"
+), ys = L(
+  [
+    "ds:h-full ds:rounded-[var(--radius-full)]",
+    "ds:transition-all ds:duration-[var(--animation-duration)] ds:motion-reduce:transition-none"
+  ].join(" "),
+  {
+    variants: {
+      level: {
+        0: "ds:w-1/4 ds:bg-destructive",
+        1: "ds:w-1/2 ds:bg-warning",
+        2: "ds:w-3/4 ds:bg-success",
+        3: "ds:w-full ds:bg-success"
+      }
+    },
+    defaultVariants: { level: 0 }
+  }
+), xs = {
+  0: "weak",
+  1: "fair",
+  2: "good",
+  3: "strong"
+}, ks = L(
+  "ds:inline-flex ds:items-center ds:gap-[var(--spacing-xs)] type-meta",
+  {
+    variants: {
+      met: {
+        true: "ds:text-success",
+        false: "ds:text-muted-foreground"
+      }
+    },
+    defaultVariants: { met: !1 }
+  }
+), Ns = ts(
+  ({
+    onRevealChange: e,
+    showStrength: r = !1,
+    strength: n,
+    requirements: l,
+    deriveStrength: p = !1,
+    autoComplete: w,
+    size: h = "md",
+    disabled: d,
+    name: i,
+    id: I,
+    onKeyDown: b,
+    onKeyUp: v,
+    onBlur: y,
+    onInput: x,
+    defaultValue: T,
+    value: m,
+    className: $,
+    ...B
+  }, G) => {
+    const { t: f } = W(), M = ns().disabled || d, k = as(null), J = os(G, k), [c, j] = C(!1), [Q, A] = C(!1), [_, H] = C(() => typeof m == "string" ? m : typeof T == "string" ? T : "");
+    is(() => {
+      typeof m == "string" && H(m);
+    }, [m]);
+    const X = u(
+      (s) => {
+        H(s.currentTarget.value), x == null || x(s);
+      },
+      [x]
+    ), z = u((s) => {
+      var R;
+      const t = k.current;
+      if (!t) return;
+      const P = Object.getPrototypeOf(t), S = (R = Object.getOwnPropertyDescriptor(P, "value")) == null ? void 0 : R.set;
+      S == null || S.call(t, s), t.dispatchEvent(new Event("input", { bubbles: !0 })), t.dispatchEvent(new Event("change", { bubbles: !0 }));
+    }, []), Y = u(() => {
+      j((s) => {
+        const t = !s;
+        return e == null || e(t), t;
+      });
+    }, [e]), N = u((s) => {
+      typeof s.getModifierState == "function" && A(s.getModifierState("CapsLock"));
+    }, []), Z = u(
+      (s) => {
+        N(s), b == null || b(s);
+      },
+      [N, b]
+    ), D = u(
+      (s) => {
+        N(s), v == null || v(s);
+      },
+      [N, v]
+    ), q = u(
+      (s) => {
+        A(!1), y == null || y(s);
+      },
+      [y]
+    ), U = V(
+      () => ({
+        getValue: () => {
+          var s;
+          return ((s = k.current) == null ? void 0 : s.value) ?? "";
+        },
+        setValue: (s) => z(s),
+        clear: () => z(""),
+        focus: () => {
+          var s;
+          return (s = k.current) == null ? void 0 : s.focus();
+        },
+        isRevealed: () => c,
+        toggleVisibility: () => {
+          j((s) => {
+            const t = !s;
+            return e == null || e(t), t;
+          });
+        }
+      }),
+      [e, c, z]
+    );
+    ds(hs, U, I);
+    const F = ws[h], ss = f(
+      c ? "ui.inputs.password.toggleHide" : "ui.inputs.password.toggleShow",
+      c ? "Hide password" : "Show password"
+    ), o = V(
+      () => (l == null ? void 0 : l.map((s) => ({
+        ...s,
+        met: s.test(_)
+      }))) ?? null,
+      [l, _]
+    ), es = V(() => {
+      if (!p || !(o != null && o.length)) return 0;
+      const s = o.filter((P) => P.met).length, t = o.length;
+      return Math.min(3, Math.floor(s / t * 4));
+    }, [p, o]), E = n !== void 0 ? n : p ? es : 0, O = xs[E], K = f(
+      `ui.inputs.password.strength.${O}`,
+      O.charAt(0).toUpperCase() + O.slice(1)
+    );
+    return /* @__PURE__ */ g(
+      "div",
+      {
+        "data-component": "password-input",
+        "data-component-id": I,
+        className: "ds:flex ds:flex-col ds:gap-[var(--spacing-xs)]",
+        children: [
+          /* @__PURE__ */ g("div", { className: "ds:relative", children: [
+            /* @__PURE__ */ a(
+              rs,
+              {
+                ref: J,
+                id: I,
+                type: c ? "text" : "password",
+                autoComplete: w ?? "current-password",
+                name: i ?? "password",
+                spellCheck: !1,
+                autoCapitalize: "none",
+                autoCorrect: "off",
+                size: h,
+                disabled: M,
+                onKeyDown: Z,
+                onKeyUp: D,
+                onBlur: q,
+                onInput: X,
+                value: m,
+                defaultValue: T,
+                endAdornment: /* @__PURE__ */ a("span", { "aria-hidden": "true", className: "ds:block ds:size-4" }),
+                className: $,
+                ...B
+              }
+            ),
+            /* @__PURE__ */ a(
+              "button",
+              {
+                type: "button",
+                "aria-pressed": c,
+                "aria-label": ss,
+                disabled: M,
+                onClick: Y,
+                className: bs(),
+                children: c ? /* @__PURE__ */ a(ls, { "aria-hidden": "true", className: F }) : /* @__PURE__ */ a(gs, { "aria-hidden": "true", className: F })
+              }
+            )
+          ] }),
+          o && o.length > 0 ? (
+            // `role="list"` / `role="listitem"` are set explicitly even
+            // though they're the implicit roles on <ul>/<li> — Safari
+            // VoiceOver strips the implicit list role when CSS sets
+            // `list-style: none` (which `ds:list-none` does), so the
+            // redundancy is load-bearing for AT, not a lint nit.
+            //
+            // aria-live="polite" announces transitions as the per-row
+            // `.ds:sr-only` state suffix flips between "met" / "not yet
+            // met". aria-live observes text-content mutations, not
+            // attribute or class changes, so the data-state attribute
+            // alone wouldn't trigger an announcement — the sr-only span
+            // is the load-bearing piece for AT users.
+            // eslint-disable-next-line jsx-a11y/no-redundant-roles
+            /* @__PURE__ */ a(
+              "ul",
+              {
+                role: "list",
+                "aria-live": "polite",
+                "data-component": "password-requirements",
+                className: "ds:list-none ds:m-0 ds:p-0 ds:flex ds:flex-col ds:gap-[var(--spacing-2xs)]",
+                children: o.map((s) => (
+                  // eslint-disable-next-line jsx-a11y/no-redundant-roles
+                  /* @__PURE__ */ g(
+                    "li",
+                    {
+                      role: "listitem",
+                      "data-state": s.met ? "met" : "unmet",
+                      className: ks({ met: s.met }),
+                      children: [
+                        s.met ? /* @__PURE__ */ a(
+                          us,
+                          {
+                            "aria-hidden": "true",
+                            className: "ds:size-3.5 ds:text-success ds:shrink-0"
+                          }
+                        ) : /* @__PURE__ */ a(
+                          ps,
+                          {
+                            "aria-hidden": "true",
+                            className: "ds:size-3.5 ds:shrink-0"
+                          }
+                        ),
+                        /* @__PURE__ */ a("span", { children: s.label }),
+                        /* @__PURE__ */ g("span", { className: "ds:sr-only", children: [
+                          " — ",
+                          s.met ? f("ui.inputs.password.requirements.met", "met") : f(
+                            "ui.inputs.password.requirements.unmet",
+                            "not yet met"
+                          )
+                        ] })
+                      ]
+                    },
+                    s.id
+                  )
+                ))
+              }
+            )
+          ) : null,
+          Q ? /* @__PURE__ */ g(
+            "span",
+            {
+              role: "status",
+              "aria-live": "polite",
+              className: "ds:inline-flex ds:items-center ds:gap-[var(--spacing-xs)] type-meta ds:text-warning",
+              children: [
+                /* @__PURE__ */ a(ms, { "aria-hidden": "true", className: "ds:size-3.5" }),
+                f("ui.inputs.password.capsLock", "Caps Lock is on")
+              ]
+            }
+          ) : null,
+          r ? /* @__PURE__ */ g("div", { className: "ds:flex ds:flex-col ds:gap-[var(--spacing-xs)]", children: [
+            /* @__PURE__ */ a(
+              "div",
+              {
+                role: "progressbar",
+                "aria-valuenow": E,
+                "aria-valuemin": 0,
+                "aria-valuemax": 3,
+                "aria-label": f(
+                  "ui.inputs.password.strengthLabel",
+                  "Password strength"
+                ),
+                "aria-valuetext": K,
+                className: vs(),
+                children: /* @__PURE__ */ a(
+                  "div",
+                  {
+                    className: ys({ level: E })
+                  }
+                )
+              }
+            ),
+            /* @__PURE__ */ a(
+              "span",
+              {
+                "aria-hidden": "true",
+                className: "type-meta ds:text-muted-foreground",
+                children: K
+              }
+            )
+          ] }) : null
+        ]
+      }
+    );
+  }
+);
+Ns.displayName = "PasswordInput";
+function Hs(e = {}) {
+  const { t: r } = W(), { minLength: n, uppercase: l, lowercase: p, digit: w, symbol: h } = e;
+  return V(() => {
+    const d = [];
+    return typeof n == "number" && n > 0 && d.push({
+      id: "length",
+      label: r("ui.inputs.password.requirements.length", {
+        count: n,
+        defaultValue: `At least ${n} characters`
+      }),
+      test: (i) => i.length >= n
+    }), l && d.push({
+      id: "uppercase",
+      label: r(
+        "ui.inputs.password.requirements.uppercase",
+        "One uppercase letter"
+      ),
+      test: (i) => new RegExp("\\p{Lu}", "u").test(i)
+    }), p && d.push({
+      id: "lowercase",
+      label: r(
+        "ui.inputs.password.requirements.lowercase",
+        "One lowercase letter"
+      ),
+      test: (i) => new RegExp("\\p{Ll}", "u").test(i)
+    }), w && d.push({
+      id: "digit",
+      label: r("ui.inputs.password.requirements.digit", "One number"),
+      test: (i) => new RegExp("\\p{Nd}", "u").test(i)
+    }), h && d.push({
+      id: "symbol",
+      label: r("ui.inputs.password.requirements.symbol", "One symbol"),
+      // Anything that isn't a letter, number, or whitespace counts.
+      // `\p{L}` + `\p{N}` keep this Unicode-aware so non-Latin
+      // alphabets (Arabic, Chinese, …) aren't mis-classified as
+      // symbols.
+      test: (i) => /[^\p{L}\p{N}\s]/u.test(i)
+    }), d;
+  }, [r, n, l, p, w, h]);
+}
+export {
+  Ns as P,
+  Hs as u
+};
+//# sourceMappingURL=use-password-requirements-DgEYdN4H.js.map

package/dist/agent-catalog.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "packageVersion": "0.7.2",
+  "packageVersion": "0.8.0",
   "components": [
     {
       "kind": "component",

package/dist/components/password-input/index.d.ts

@@ -1,3 +1,5 @@
 export { PasswordInput } from './password-input';
-export type { PasswordInputProps } from './password-input';
+export type { PasswordInputProps, PasswordRequirement } from './password-input';
+export { usePasswordRequirements } from './use-password-requirements';
+export type { UsePasswordRequirementsOptions } from './use-password-requirements';
 //# sourceMappingURL=index.d.ts.map

package/dist/components/password-input/index.js

@@ -1,5 +1,6 @@
-import { P as s } from "../../_chunks/password-input-C4LmjIH1.js";
+import { P as r, u as a } from "../../_chunks/use-password-requirements-DgEYdN4H.js";
 export {
-  s as PasswordInput
+  r as PasswordInput,
+  a as usePasswordRequirements
 };
 //# sourceMappingURL=index.js.map

package/dist/components/password-input/password-input.d.ts

@@ -13,6 +13,18 @@ type Strength = 0 | 1 | 2 | 3;
 declare const strengthBarVariants: (props?: ({
     level?: 0 | 2 | 1 | 3 | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * One row in the live requirements checklist. Consumers either build
+ * these inline or pull a pre-built set from `usePasswordRequirements`.
+ */
+export interface PasswordRequirement {
+    /** Stable id — keyed render + a11y. */
+    id: string;
+    /** Already-translated label. The consumer owns the wording. */
+    label: string;
+    /** Predicate against the current value. Pure, runs on every keystroke. */
+    test: (value: string) => boolean;
+}
 export interface PasswordInputProps extends Omit<TextInputProps, 'type' | 'endAdornment' | 'startAdornment'>, VariantProps<typeof strengthBarVariants> {
     /** Callback when reveal state changes (for analytics). */
     onRevealChange?: (revealed: boolean) => void;
@@ -20,6 +32,25 @@ export interface PasswordInputProps extends Omit<TextInputProps, 'type' | 'endAd
     showStrength?: boolean;
     /** Strength score: 0 = weak, 1 = fair, 2 = good, 3 = strong. */
     strength?: Strength;
+    /**
+     * Live requirements checklist rendered between the input and the
+     * strength meter / caps-lock notice. Each row's predicate runs on
+     * every keystroke and the row's `data-state` flips between `"met"`
+     * and `"unmet"`. Backed by `aria-live="polite"` so screen readers
+     * announce each transition as a visually-hidden suffix span flips
+     * between localised "met" / "not yet met" copy.
+     *
+     * Tip: hoist or `useMemo` the array — inlining it in JSX makes the
+     * predicate-results memo bust every render. The kit's
+     * `usePasswordRequirements` helper already does this.
+     */
+    requirements?: ReadonlyArray<PasswordRequirement>;
+    /**
+     * When `true` AND `strength` is not provided, derive a 0–3 score
+     * from the proportion of `requirements` satisfied. Lets consumers
+     * get the strength bar "for free" once they declare requirements.
+     */
+    deriveStrength?: boolean;
     /**
      * Autocomplete hint. Defaults to 'current-password'.
      * Use 'new-password' for registration/change-password forms.

package/dist/components/password-input/use-password-requirements.d.ts

@@ -0,0 +1,39 @@
+import type { PasswordRequirement } from './password-input';
+export interface UsePasswordRequirementsOptions {
+    /**
+     * Minimum password length. When set, adds a "length" requirement.
+     * Pass `12` (or whatever the server-side regex enforces) so the
+     * inline checklist tells users the same rule they'll bounce off
+     * server-side. When omitted, no length row is rendered.
+     */
+    minLength?: number;
+    /** Adds an "uppercase letter" requirement when true. */
+    uppercase?: boolean;
+    /** Adds a "lowercase letter" requirement when true. */
+    lowercase?: boolean;
+    /** Adds a "digit" requirement when true. */
+    digit?: boolean;
+    /** Adds a "symbol" requirement when true. Matches anything outside `[A-Za-z0-9\s]`. */
+    symbol?: boolean;
+}
+/**
+ * Builds the common set of password requirements with i18n-resolved
+ * labels. Designed for the AlfaDocs platform's patient-registration
+ * server-side regex (`/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{12,}$/`) but
+ * generic enough for any consumer.
+ *
+ * Each opt-in flag adds one row to the returned array, in a stable
+ * visual order (length → uppercase → lowercase → digit → symbol).
+ * Predicates are pure and run on every keystroke.
+ *
+ * @example
+ *   const requirements = usePasswordRequirements({
+ *     minLength: 12,
+ *     uppercase: true,
+ *     lowercase: true,
+ *     digit: true,
+ *   });
+ *   <PasswordInput requirements={requirements} deriveStrength />
+ */
+export declare function usePasswordRequirements(opts?: UsePasswordRequirementsOptions): PasswordRequirement[];
+//# sourceMappingURL=use-password-requirements.d.ts.map

package/dist/i18n/config.js

@@ -1,5 +1,5 @@
 import n from "i18next";
-import { default as m } from "i18next";
+import { default as g } from "i18next";
 import { initReactI18next as i } from "react-i18next";
 const e = {
   common: {
@@ -66,6 +66,16 @@ const e = {
         fair: "Fair",
         good: "Good",
         strong: "Strong"
+      },
+      requirements: {
+        length_one: "At least {{count}} character",
+        length_other: "At least {{count}} characters",
+        uppercase: "One uppercase letter",
+        lowercase: "One lowercase letter",
+        digit: "One number",
+        symbol: "One symbol",
+        met: "met",
+        unmet: "not yet met"
       }
     },
     textarea: {
@@ -1028,6 +1038,16 @@ const e = {
         fair: "Discreta",
         good: "Buona",
         strong: "Forte"
+      },
+      requirements: {
+        length_one: "Almeno {{count}} carattere",
+        length_other: "Almeno {{count}} caratteri",
+        uppercase: "Una lettera maiuscola",
+        lowercase: "Una lettera minuscola",
+        digit: "Un numero",
+        symbol: "Un simbolo",
+        met: "soddisfatto",
+        unmet: "non ancora soddisfatto"
       }
     },
     textarea: {
@@ -1958,6 +1978,16 @@ const e = {
       toggleHide: "Passwort verbergen",
       capsLock: "Feststelltaste ist aktiviert",
       strengthLabel: "Passwortstärke",
+      requirements: {
+        length_one: "Mindestens {{count}} Zeichen",
+        length_other: "Mindestens {{count}} Zeichen",
+        uppercase: "Ein Großbuchstabe",
+        lowercase: "Ein Kleinbuchstabe",
+        digit: "Eine Zahl",
+        symbol: "Ein Sonderzeichen",
+        met: "erfüllt",
+        unmet: "noch nicht erfüllt"
+      },
       strength: {
         weak: "Schwach",
         fair: "Mittel",
@@ -2874,7 +2904,7 @@ n.use(i).init({
 export {
   u as LOCALES_WITH_BUNDLES,
   t as arUi,
-  m as default,
+  g as default,
   e as enUi,
   d as uiResources
 };

package/dist/i18n/resources.d.ts

@@ -65,6 +65,16 @@ export declare const enUi: {
                 readonly good: "Good";
                 readonly strong: "Strong";
             };
+            readonly requirements: {
+                readonly length_one: "At least {{count}} character";
+                readonly length_other: "At least {{count}} characters";
+                readonly uppercase: "One uppercase letter";
+                readonly lowercase: "One lowercase letter";
+                readonly digit: "One number";
+                readonly symbol: "One symbol";
+                readonly met: "met";
+                readonly unmet: "not yet met";
+            };
         };
         readonly textarea: {
             readonly charactersRemaining_one: "{{count}} character remaining";
@@ -1046,6 +1056,16 @@ export declare const itUi: {
                 readonly good: "Buona";
                 readonly strong: "Forte";
             };
+            readonly requirements: {
+                readonly length_one: "Almeno {{count}} carattere";
+                readonly length_other: "Almeno {{count}} caratteri";
+                readonly uppercase: "Una lettera maiuscola";
+                readonly lowercase: "Una lettera minuscola";
+                readonly digit: "Un numero";
+                readonly symbol: "Un simbolo";
+                readonly met: "soddisfatto";
+                readonly unmet: "non ancora soddisfatto";
+            };
         };
         readonly textarea: {
             readonly charactersRemaining_one: "{{count}} carattere rimanente";
@@ -2000,6 +2020,16 @@ export declare const deUi: {
             readonly toggleHide: "Passwort verbergen";
             readonly capsLock: "Feststelltaste ist aktiviert";
             readonly strengthLabel: "Passwortstärke";
+            readonly requirements: {
+                readonly length_one: "Mindestens {{count}} Zeichen";
+                readonly length_other: "Mindestens {{count}} Zeichen";
+                readonly uppercase: "Ein Großbuchstabe";
+                readonly lowercase: "Ein Kleinbuchstabe";
+                readonly digit: "Eine Zahl";
+                readonly symbol: "Ein Sonderzeichen";
+                readonly met: "erfüllt";
+                readonly unmet: "noch nicht erfüllt";
+            };
             readonly strength: {
                 readonly weak: "Schwach";
                 readonly fair: "Mittel";