nextjs-cms 0.9.37 → 0.9.39

package/dist/core/helpers/conditional-rules.js

@@ -0,0 +1,113 @@
+/**
+ * Normalize a value to the string form used for comparison.
+ *
+ * Form values reach us as strings (`FormData`) on the server and as strings, numbers or booleans on
+ * the client, so every condition compares string representations. An absent value (`undefined`, or
+ * the `null` returned by `FormData.get()` for a missing key) normalizes to `undefined` so it is never
+ * confused with the literal string `'undefined'`.
+ */
+function normalize(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    return String(value);
+}
+/**
+ * Coerce a normalized value to a number for the ordering conditions.
+ *
+ * Returns `NaN` for absent, blank and non-numeric values so that every ordering comparison against
+ * them is false — an ordering condition is only met when both sides are real numbers.
+ */
+function toComparableNumber(value) {
+    if (value === undefined || value.trim() === '')
+        return NaN;
+    return Number(value);
+}
+/**
+ * Evaluate a single conditional rule against the current value of its controlling field.
+ *
+ * This is the one place conditions are interpreted. It is shared by the admin UI (deciding whether to
+ * render a conditional field) and by submit (deciding whether to persist it), so a field can never be
+ * visible in the form but silently dropped on save.
+ *
+ * Notes on semantics:
+ * - `equals` / `notEquals` / `contains` / `notContains` compare string representations; `contains` is
+ *   case sensitive.
+ * - The ordering conditions require both sides to be numeric, and are false otherwise.
+ * - When the controlling field has no value, negative conditions (`notEquals`, `notContains`) are met
+ *   and every other condition is not.
+ *
+ * @param rule The rule to evaluate: the condition and the value it expects.
+ * @param actualValue The current value of the controlling field.
+ */
+export function evaluateConditionalRule(rule, actualValue) {
+    const actual = normalize(actualValue);
+    const expected = normalize(rule.value);
+    switch (rule.condition) {
+        case 'equals':
+            return actual === expected;
+        case 'notEquals':
+            return actual !== expected;
+        case 'contains':
+            return actual !== undefined && expected !== undefined && actual.includes(expected);
+        case 'notContains':
+            return !(actual !== undefined && expected !== undefined && actual.includes(expected));
+        case 'greaterThan':
+            return toComparableNumber(actual) > toComparableNumber(expected);
+        case 'lessThan':
+            return toComparableNumber(actual) < toComparableNumber(expected);
+        case 'greaterThanOrEquals':
+            return toComparableNumber(actual) >= toComparableNumber(expected);
+        case 'lessThanOrEquals':
+            return toComparableNumber(actual) <= toComparableNumber(expected);
+        default:
+            return false;
+    }
+}
+/**
+ * Combine conditional rules with AND semantics — the dependent field is active only when every rule
+ * passes. Use in a field's `conditionalRules` when it declares two or more rules.
+ */
+export function and(...rules) {
+    return { match: 'all', rules };
+}
+/**
+ * Combine conditional rules with OR semantics — the dependent field is active when at least one rule
+ * passes. Use in a field's `conditionalRules` when it declares two or more rules.
+ */
+export function or(...rules) {
+    return { match: 'any', rules };
+}
+/**
+ * Normalize a field's `conditionalRules` config into a single {@link ConditionalRuleGroup}.
+ *
+ * A single-rule array (the no-wrapper form) becomes an `all` group; an `and()` / `or()` group passes
+ * through unchanged. Returns `undefined` when there are no rules, which callers treat as "not
+ * conditional". Accepts a bare multi-rule array at runtime for resilience, though the config type
+ * forbids it so authors are pushed to `and()` / `or()`.
+ */
+export function normalizeConditionalRules(input) {
+    if (!input)
+        return undefined;
+    if (Array.isArray(input)) {
+        if (input.length === 0)
+            return undefined;
+        return { match: 'all', rules: input };
+    }
+    return input;
+}
+/**
+ * Evaluate a whole rule group against the current form state.
+ *
+ * Value resolution is delegated to `resolveValue` so this works on both layers: the server passes a
+ * resolver backed by submitted `FormData`, the client one backed by the live field values. Each rule
+ * is resolved against its own controlling field. An empty group never matches.
+ *
+ * @param group The group to evaluate, with its `all` / `any` combining operator.
+ * @param resolveValue Returns the current value of the field a given rule controls on.
+ */
+export function evaluateConditionalRuleGroup(group, resolveValue) {
+    if (!group.rules || group.rules.length === 0)
+        return false;
+    const results = group.rules.map((rule) => evaluateConditionalRule(rule, resolveValue(rule)));
+    return group.match === 'any' ? results.some((result) => result) : results.every((result) => result);
+}

package/dist/core/helpers/index.d.ts

@@ -2,4 +2,5 @@ export { is } from './entity.js';
 export { entityKind } from './entity.js';
 export type { LZEntity } from './entity.js';
 export { hasOwnEntityKind } from './entity.js';
+export { evaluateConditionalRule, evaluateConditionalRuleGroup, normalizeConditionalRules } from './conditional-rules.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/helpers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/helpers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAA;AAChC,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AACxC,YAAY,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/helpers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAA;AAChC,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AACxC,YAAY,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAI9C,OAAO,EAAE,uBAAuB,EAAE,4BAA4B,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAA"}

package/dist/core/helpers/index.js

@@ -1,3 +1,7 @@
 export { is } from './entity.js';
 export { entityKind } from './entity.js';
 export { hasOwnEntityKind } from './entity.js';
+// Note: the `and` / `or` authoring wrappers are re-exported from `core/fields` (alongside the field
+// factories that section configs use), so they are intentionally not re-exported here to avoid a
+// duplicate export when `core/index` merges both barrels.
+export { evaluateConditionalRule, evaluateConditionalRuleGroup, normalizeConditionalRules } from './conditional-rules.js';