@easy-cms/core 0.45.0 → 0.47.0

package/dist/chunk-C4KJ5TFK.js

@@ -0,0 +1,48 @@
+// src/conditions.ts
+var empty = (value) => value === void 0 || value === null || value === "" || value === false || Array.isArray(value) && value.length === 0;
+var plain = (value) => value && typeof value === "object" && !Array.isArray(value) && "id" in value ? value.id : value;
+var same = (a, b) => {
+  const x = plain(a);
+  const y = plain(b);
+  if (Array.isArray(x)) return x.some((v) => same(v, y));
+  return x === y || x !== null && y !== null && x !== void 0 && String(x) === String(y);
+};
+function read(data, path) {
+  let current = data;
+  for (const key of path.split(".")) {
+    if (typeof current !== "object" || current === null) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function matchesCondition(condition, data) {
+  if ("and" in condition) return condition.and.every((c) => matchesCondition(c, data));
+  if ("or" in condition) return condition.or.some((c) => matchesCondition(c, data));
+  if ("not" in condition) return !matchesCondition(condition.not, data);
+  const value = read(data, condition.field);
+  if (condition.exists !== void 0 && empty(value) === condition.exists) return false;
+  if ("equals" in condition && !same(value, condition.equals)) return false;
+  if ("notEquals" in condition && same(value, condition.notEquals)) return false;
+  if (condition.in && !condition.in.some((v) => same(value, v))) return false;
+  return true;
+}
+function conditionIssues(condition, siblings) {
+  if (typeof condition !== "object" || condition === null || Array.isArray(condition))
+    return ['must be an object, e.g. { field: "type", equals: "link" }'];
+  const c = condition;
+  if (Array.isArray(c.and)) return c.and.flatMap((x) => conditionIssues(x, siblings));
+  if (Array.isArray(c.or)) return c.or.flatMap((x) => conditionIssues(x, siblings));
+  if ("not" in c) return conditionIssues(c.not, siblings);
+  if (typeof c.field !== "string" || c.field === "") return ["needs `field`, a sibling field"];
+  const first = c.field.split(".")[0];
+  if (!siblings.includes(first)) return [`"${c.field}" is not a field beside it`];
+  if (c.in !== void 0 && !Array.isArray(c.in)) return ["`in` must be a list"];
+  if (c.exists !== void 0 && typeof c.exists !== "boolean")
+    return ["`exists` must be true or false"];
+  return [];
+}
+
+export {
+  matchesCondition,
+  conditionIssues
+};

package/dist/conditions.d.ts

@@ -0,0 +1,31 @@
+/**
+ * When a field is shown, from its sibling fields' values (the fields beside it, in its group,
+ * array row or block):
+ *
+ * - `{ field: 'linkType', equals: 'external' }`, also `notEquals`, `in: [...]`, `exists: true`
+ * - `{ and: [...] }`, `{ or: [...] }`, `{ not: … }`
+ *
+ * A hidden field isn't required, and keeps its value.
+ */
+type FieldCondition = {
+    /** A sibling field's name; a path with `.` reads inside a group, e.g. `link.type`. */
+    readonly field: string;
+    readonly equals?: unknown;
+    readonly notEquals?: unknown;
+    readonly in?: readonly unknown[];
+    /** `true`: has a value (not empty); `false`: empty. */
+    readonly exists?: boolean;
+} | {
+    readonly and: readonly FieldCondition[];
+} | {
+    readonly or: readonly FieldCondition[];
+} | {
+    readonly not: FieldCondition;
+};
+type Data = Record<string, unknown>;
+/** Whether a condition holds for the sibling data. */
+declare function matchesCondition(condition: FieldCondition, data: Data): boolean;
+/** Problems with a condition, for the config's checks; `[]` when it's fine. */
+declare function conditionIssues(condition: unknown, siblings: readonly string[]): string[];
+
+export { type FieldCondition, conditionIssues, matchesCondition };

package/dist/conditions.js

@@ -0,0 +1,8 @@
+import {
+  conditionIssues,
+  matchesCondition
+} from "./chunk-C4KJ5TFK.js";
+export {
+  conditionIssues,
+  matchesCondition
+};