@rokt/dcui-orchestrator 1.2.1-rc.51 → 1.2.1-rc.52

package/dist/libraries/dcui-components/src/failure-codes.d.ts

@@ -6,3 +6,4 @@ export declare const FAILED_TO_MAP_STATIC_DATA = "FAILED_TO_MAP_STATIC_DATA";
 export declare const FAILED_SANITISING_HTML = "FAILED_SANITISING_HTML";
 export declare const UNRESOLVED_FORM_VALIDATION_TARGET = "UNRESOLVED_FORM_VALIDATION_TARGET";
 export declare const MISSING_LEAD_IDENTITY = "MISSING_LEAD_IDENTITY";
+export declare const UNSAFE_FORM_VALIDATION_PATTERN = "UNSAFE_FORM_VALIDATION_PATTERN";

package/dist/libraries/domain/src/models/form-state.d.ts

@@ -83,3 +83,88 @@ export interface FormFieldRef {
  * ActionButton (to gate dispatch) so both resolve entries identically.
  */
 export declare function resolveFormFieldRefs(formStates: FormStatesState, entries: string[]): FormFieldRef[];
+/**
+ * The longest `Pattern` a layout may register. A longer one is refused by
+ * {@link scanPattern}: the form-state reducer drops it at registration and
+ * {@link matchesPattern} treats it as non-blocking.
+ */
+export declare const MAX_PATTERN_LENGTH = 256;
+/**
+ * The longest value a `Pattern` validation tests, whatever the pattern. A
+ * longer value fails the validation with its message, untested. The rules of
+ * {@link scanPattern} bound the engine's work on a value of this length and
+ * on no other.
+ */
+export declare const MAX_PATTERN_VALUE_LENGTH = 512;
+/** Why {@link scanPattern} refused a pattern: the first rule it broke. */
+export type PatternRefusal = 'too-long' | 'backreference' | 'nested-quantifier' | 'repeated-alternation' | 'quantified-lookaround' | 'too-many-repetitions' | 'count-too-wide' | 'too-many-ways' | 'too-many-steps' | 'invalid';
+/** What {@link scanPattern} read: the verdict, with a refusal's reason. */
+export type PatternScan = {
+    safe: true;
+} | {
+    safe: false;
+    reason: PatternRefusal;
+};
+/**
+ * The walk behind {@link isSafePattern}: one pass over the pattern's syntax,
+ * with no reading of what the atoms match. Escapes and `[...]` classes are
+ * one token each, so a `(`, `|` or `*` inside them is literal. The rules are
+ * blunt by design: each refuses a shape that can backtrack past the value
+ * cap, and with it the safe patterns of the same shape. The check that reads
+ * a pattern's real cost belongs at publish time, in the service that stores
+ * the layout. Refused, in the order the rules are read:
+ *
+ * 1. a pattern longer than {@link MAX_PATTERN_LENGTH};
+ * 2. a backreference, `\1` or `\k<name>`;
+ * 3. a repeated group that holds a quantifier of its own, at any depth:
+ *    `(a+)+`, `(\d{3}-?)+`, `(a+){3}`. A `?` or a `{1}` on the group takes
+ *    it whole or not at all, so `(a+)?` is accepted. A fixed count is copies
+ *    of the group in sequence, so `(\d{4}[- ]?){3}` is accepted;
+ * 4. a repeated group that holds a `|`, at any depth: `(a|ab)+`. A fixed
+ *    count is copies here too, so `(?:a|ab){3}` is accepted;
+ * 5. a quantifier on a lookaround, inside one, or on a group that holds
+ *    one: `(?=a)+`, `(?=.*\d)`, `(?:(?=a)b){3}`;
+ * 6. more than {@link MAX_REPETITIONS} repetitions that can run on in the
+ *    whole pattern, or more than {@link MAX_ANCHORED_REPETITIONS} in one
+ *    anchored at `^`: `\w*\w*\w*-`, `^\w*\w*\w*\w*$`, where `^\w*\w*\w*$`
+ *    and `^[^\s@]+@[^\s@]+\.[^\s@]+$` are accepted;
+ * 7. a count past {@link MAX_PATTERN_VALUE_LENGTH}, on its own or multiplied
+ *    through the counts of the groups that hold it: `\w{513}`, `.{0,1000}`,
+ *    `(?:\b){999}`, `(?:(?:\b){512}){512}`;
+ * 8. {@link MAX_WAYS_STEPS} steps or more from the ways alone: each atom's
+ *    count, once per way of the atoms before it. Thirty `a?`, eight
+ *    `\d{1,9}`, `^(?:\d{1,9}){5}\w{467}$` and sixteen `a?` before `\w{495}$`
+ *    are refused, where a phone, card, IPv4 or optional-scheme URL pattern
+ *    is accepted;
+ * 9. {@link MAX_PATTERN_STEPS} steps or more from the ways and the runs
+ *    together: the same sum, each run multiplying the paths to the atoms
+ *    after it by the cap over the run's rank on its own path (its branch
+ *    and the branches of the groups that hold it, never a sibling `|`
+ *    alternative, so the branches of a `|` add up), and a pattern with no
+ *    `^` running from every position. Twelve `a?` before `\w*\w*$`,
+ *    `\w*\w*-`, `^\w*\w*\w{511}$` and `^\w*!|^` with nine `a?` before
+ *    `\w*\w*!` are refused, where `^\w*\w*\w*!`, `\S+@\S+` and `^\S+@\S+$`
+ *    are accepted;
+ * 10. a pattern RegExp rejects, as `(`.
+ *
+ * An accepted pattern is tested on a value of {@link MAX_PATTERN_VALUE_LENGTH}
+ * characters at most; {@link matchesPattern} fails a longer value untested.
+ */
+export declare function scanPattern(pattern: string): PatternScan;
+/**
+ * Whether a layout author's `Pattern` can be tested without hanging the
+ * plugin. The regular expression runs synchronously on the UI thread, inside
+ * a reducer, on every keystroke, and cannot be interrupted, so the only
+ * control is on the pattern's shape before it runs: the rules of
+ * {@link scanPattern}. A `pattern` that is no string is not refused, so a
+ * layout no schema checked still registers, but {@link matchesPattern}
+ * never compiles it.
+ */
+export declare function isSafePattern(pattern: string): boolean;
+/**
+ * Whether a validation may be registered on a field: every validation but a
+ * `Pattern` that {@link isSafePattern} refuses. Shared by the form-state
+ * reducer, which drops the refused ones, and the TextInput, which reports
+ * them, so the two never disagree on what was dropped.
+ */
+export declare function isSafeInputValidation(validation: InputValidation): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rokt/dcui-orchestrator",
-  "version": "1.2.1-rc.51",
+  "version": "1.2.1-rc.52",
   "description": "Rokt's DCUI rendering process",
   "main": "dist/index.cjs",
   "module": "dist/index.js",