@beabee/beabee-common 1.19.7 → 1.19.9

package/dist/esm/search/notices.js

@@ -1,37 +1,34 @@
-import { ItemStatus } from "../data/index.js";
-const noticeFilters = {
-  id: {
-    type: "text"
-  },
-  createdAt: {
-    type: "date"
-  },
-  updatedAt: {
-    type: "date"
-  },
-  name: {
-    type: "text"
-  },
-  expires: {
-    type: "date",
-    nullable: true
-  },
-  enabled: {
-    type: "boolean"
-  },
-  text: {
-    type: "text"
-  },
-  status: {
-    type: "enum",
-    options: [
-      ItemStatus.Draft,
-      ItemStatus.Scheduled,
-      ItemStatus.Open,
-      ItemStatus.Ended
-    ]
-  }
-};
-export {
-  noticeFilters
+import { ItemStatus } from "../data";
+export const noticeFilters = {
+    id: {
+        type: "text",
+    },
+    createdAt: {
+        type: "date",
+    },
+    updatedAt: {
+        type: "date",
+    },
+    name: {
+        type: "text",
+    },
+    expires: {
+        type: "date",
+        nullable: true,
+    },
+    enabled: {
+        type: "boolean",
+    },
+    text: {
+        type: "text",
+    },
+    status: {
+        type: "enum",
+        options: [
+            ItemStatus.Draft,
+            ItemStatus.Scheduled,
+            ItemStatus.Open,
+            ItemStatus.Ended,
+        ],
+    },
 };

package/dist/esm/search/payments.js

@@ -1,27 +1,24 @@
-import { PaymentStatus } from "../data/index.js";
-const paymentFilters = {
-  id: {
-    type: "text"
-  },
-  contact: {
-    type: "contact"
-  },
-  chargeDate: {
-    type: "date"
-  },
-  amount: {
-    type: "number"
-  },
-  status: {
-    type: "enum",
-    options: [
-      PaymentStatus.Successful,
-      PaymentStatus.Pending,
-      PaymentStatus.Failed,
-      PaymentStatus.Cancelled
-    ]
-  }
-};
-export {
-  paymentFilters
+import { PaymentStatus } from "../data";
+export const paymentFilters = {
+    id: {
+        type: "text",
+    },
+    contact: {
+        type: "contact",
+    },
+    chargeDate: {
+        type: "date",
+    },
+    amount: {
+        type: "number",
+    },
+    status: {
+        type: "enum",
+        options: [
+            PaymentStatus.Successful,
+            PaymentStatus.Pending,
+            PaymentStatus.Failed,
+            PaymentStatus.Cancelled,
+        ],
+    },
 };

package/dist/esm/utils/callouts.js

@@ -1,106 +1,108 @@
 function isNestableComponent(component) {
-  return "components" in component && component.type !== "address";
+    // Addresses have embedded components we don't want to include
+    return "components" in component && component.type !== "address";
 }
 function convertValuesToOptions(values) {
-  return values.map(({ value }) => value);
+    return values.map(({ value, label }) => value);
 }
 function convertComponentToFilter(component) {
-  const baseItem = {
-    label: component.label || component.fullKey,
-    nullable: true
-  };
-  switch (component.type) {
-    case "checkbox":
-      return { ...baseItem, type: "boolean", nullable: false };
-    case "number":
-      return { ...baseItem, type: "number" };
-    case "select":
-      return {
-        ...baseItem,
-        type: "enum",
-        options: convertValuesToOptions(component.data.values)
-      };
-    case "selectboxes":
-    case "radio":
-      return {
-        ...baseItem,
-        type: component.type === "radio" ? "enum" : "array",
-        options: convertValuesToOptions(component.values)
-      };
-    case "textarea":
-      return { ...baseItem, type: "blob" };
-    default:
-      return { ...baseItem, type: "text" };
-  }
+    const baseItem = {
+        label: component.label || component.fullKey,
+        nullable: true,
+    };
+    switch (component.type) {
+        case "checkbox":
+            return { ...baseItem, type: "boolean", nullable: false };
+        case "number":
+            return { ...baseItem, type: "number" };
+        case "select":
+            return {
+                ...baseItem,
+                type: "enum",
+                options: convertValuesToOptions(component.data.values),
+            };
+        case "selectboxes":
+        case "radio":
+            return {
+                ...baseItem,
+                type: component.type === "radio" ? "enum" : "array",
+                options: convertValuesToOptions(component.values),
+            };
+        case "textarea":
+            return { ...baseItem, type: "blob" };
+        default:
+            return { ...baseItem, type: "text" };
+    }
 }
 function getNiceAnswer(component, value) {
-  switch (component.type) {
-    case "radio":
-    case "selectboxes":
-      return component.values.find((v) => v.value === value)?.label || value;
-    case "select":
-      return component.data.values.find((v) => v.value === value)?.label || value;
-    default:
-      return value;
-  }
+    switch (component.type) {
+        case "radio":
+        case "selectboxes":
+            return component.values.find((v) => v.value === value)?.label || value;
+        case "select":
+            return (component.data.values.find((v) => v.value === value)?.label || value);
+        default:
+            return value;
+    }
 }
-function flattenComponents(components) {
-  return components.flatMap(
-    (component) => isNestableComponent(component) ? [component, ...flattenComponents(component.components)] : [component]
-  );
+export function flattenComponents(components) {
+    return components.flatMap((component) => isNestableComponent(component)
+        ? [component, ...flattenComponents(component.components)]
+        : [component]);
 }
-function filterComponents(components, filterFn) {
-  return components.filter(filterFn).map((component) => {
-    return {
-      ...component,
-      ...isNestableComponent(component) && {
-        components: filterComponents(component.components, filterFn)
-      }
-    };
-  });
+export function filterComponents(components, filterFn) {
+    return components.filter(filterFn).map((component) => {
+        return {
+            ...component,
+            ...(isNestableComponent(component) && {
+                components: filterComponents(component.components, filterFn),
+            }),
+        };
+    });
 }
-function getCalloutComponents(formSchema) {
-  return formSchema.slides.flatMap(
-    (slide) => flattenComponents(slide.components).map((component) => ({
-      ...component,
-      slideId: slide.id,
-      fullKey: `${slide.id}.${component.key}`
-    }))
-  );
+export function getCalloutComponents(formSchema) {
+    return formSchema.slides.flatMap((slide) => flattenComponents(slide.components).map((component) => ({
+        ...component,
+        slideId: slide.id,
+        fullKey: `${slide.id}.${component.key}`,
+    })));
 }
-function getCalloutFilters(formSchema) {
-  const items = getCalloutComponents(formSchema).filter((c) => c.input).map((c) => [`answers.${c.fullKey}`, convertComponentToFilter(c)]);
-  return Object.fromEntries(items);
+export function getCalloutFilters(formSchema) {
+    const items = getCalloutComponents(formSchema)
+        .filter((c) => c.input)
+        .map((c) => [`answers.${c.fullKey}`, convertComponentToFilter(c)]);
+    return Object.fromEntries(items);
 }
-function isAddressAnswer(answer) {
-  return !!answer && typeof answer === "object" && "geometry" in answer;
+export function isAddressAnswer(answer) {
+    return !!answer && typeof answer === "object" && "geometry" in answer;
 }
-function isFileUploadAnswer(answer) {
-  return !!answer && typeof answer === "object" && "url" in answer;
+export function isFileUploadAnswer(answer) {
+    return !!answer && typeof answer === "object" && "url" in answer;
 }
-function stringifyAnswer(component, answer) {
-  if (Array.isArray(answer)) {
-    return answer.map((a) => stringifyAnswer(component, a)).join(", ");
-  } else if (!answer) {
-    return "";
-  } else if (isAddressAnswer(answer)) {
-    return answer.geometry.location.lat + ", " + answer.geometry.location.lng;
-  } else if (isFileUploadAnswer(answer)) {
-    return answer.url;
-  } else if (typeof answer === "object") {
-    return Object.entries(answer).filter(([, selected]) => selected).map(([value]) => getNiceAnswer(component, value)).join(", ");
-  } else if (typeof answer === "string") {
-    return getNiceAnswer(component, answer);
-  } else {
-    return answer.toString();
-  }
+export function stringifyAnswer(component, answer) {
+    if (Array.isArray(answer)) {
+        return answer.map((a) => stringifyAnswer(component, a)).join(", ");
+    }
+    else if (!answer) {
+        return "";
+    }
+    else if (isAddressAnswer(answer)) {
+        return answer.geometry.location.lat + ", " + answer.geometry.location.lng;
+    }
+    else if (isFileUploadAnswer(answer)) {
+        return answer.url;
+    }
+    else if (typeof answer === "object") {
+        // Checkboxes
+        return Object.entries(answer)
+            .filter(([, selected]) => selected)
+            .map(([value]) => getNiceAnswer(component, value))
+            .join(", ");
+    }
+    else if (typeof answer === "string") {
+        return getNiceAnswer(component, answer);
+    }
+    else {
+        return answer.toString();
+    }
 }
-export {
-  filterComponents,
-  flattenComponents,
-  getCalloutComponents,
-  getCalloutFilters,
-  isAddressAnswer,
-  isFileUploadAnswer,
-  stringifyAnswer
-};

package/dist/esm/utils/date.js

@@ -1,68 +1,68 @@
-import {
-  add,
-  isValid,
-  parseISO,
-  startOfDay,
-  startOfHour,
-  startOfMinute,
-  startOfMonth,
-  startOfSecond,
-  startOfYear
-} from "date-fns";
+import add from "date-fns/add";
+import isValid from "date-fns/isValid";
+import parseISO from "date-fns/parseISO";
+import startOfDay from "date-fns/startOfDay";
+import startOfHour from "date-fns/startOfHour";
+import startOfMinute from "date-fns/startOfMinute";
+import startOfMonth from "date-fns/startOfMonth";
+import startOfSecond from "date-fns/startOfSecond";
+import startOfYear from "date-fns/startOfYear";
+// Must be ordered from highest resolution to lowest (seconds to years)
 const dateUnits = ["s", "m", "h", "d", "M", "y"];
 const dateUnitMap = {
-  y: "years",
-  M: "months",
-  d: "days",
-  h: "hours",
-  m: "minutes",
-  s: "seconds"
+    y: "years",
+    M: "months",
+    d: "days",
+    h: "hours",
+    m: "minutes",
+    s: "seconds",
 };
 const startOf = {
-  y: startOfYear,
-  M: startOfMonth,
-  d: startOfDay,
-  h: startOfHour,
-  m: startOfMinute,
-  s: startOfSecond
+    y: startOfYear,
+    M: startOfMonth,
+    d: startOfDay,
+    h: startOfHour,
+    m: startOfMinute,
+    s: startOfSecond,
 };
 const relativeDate = /^\$now(?<units>\(((y|M|d|h|m|s):(-?\d+),?)+\))?$/;
 const relativeUnit = /(y|M|d|h|m|s):(-?\d+)/g;
+// Matches the different parts of an ISO 8601 date. Note we don't validate the
+// pattern properly as that is handled by parseISO, we just want to know which
+// parts of the date were specified
 const absoluteDate = /^(?<y>\d{4,})(-(?<M>\d\d)(-(?<d>\d\d)([T ](?<h>\d\d)(:(?<m>\d\d)(:(?<s>\d\d))?)?)?)?)?/;
-function parseDate(value, now) {
-  let date;
-  let units;
-  const relativeMatch = relativeDate.exec(value);
-  if (relativeMatch) {
-    date = now || /* @__PURE__ */ new Date();
-    const unitsGroup = relativeMatch.groups?.units;
-    if (unitsGroup) {
-      const unitMatches = unitsGroup.matchAll(relativeUnit);
-      units = [];
-      for (const [_, unit, delta] of unitMatches) {
-        date = add(date, { [dateUnitMap[unit]]: Number(delta) });
-        units.push(unit);
-      }
-    } else {
-      units = ["d"];
+// Convert relative dates and returns the minimum date unit specified
+export function parseDate(value, now) {
+    let date;
+    let units;
+    const relativeMatch = relativeDate.exec(value);
+    if (relativeMatch) {
+        date = now || new Date();
+        const unitsGroup = relativeMatch.groups?.units;
+        if (unitsGroup) {
+            const unitMatches = unitsGroup.matchAll(relativeUnit);
+            units = [];
+            for (const [_, unit, delta] of unitMatches) {
+                date = add(date, { [dateUnitMap[unit]]: Number(delta) });
+                units.push(unit);
+            }
+        }
+        else {
+            units = ["d"];
+        }
     }
-  } else {
-    date = parseISO(value);
-    units = Object.entries(absoluteDate.exec(value)?.groups || {}).filter(([_, n]) => !!n).map(([unit]) => unit);
-  }
-  const minUnit = getMinDateUnit(units) || "s";
-  return [startOf[minUnit](date), minUnit];
+    else {
+        date = parseISO(value);
+        units = Object.entries(absoluteDate.exec(value)?.groups || {})
+            .filter(([_, n]) => !!n)
+            .map(([unit]) => unit);
+    }
+    const minUnit = getMinDateUnit(units) || "s";
+    return [startOf[minUnit](date), minUnit];
 }
-function getMinDateUnit(units) {
-  return dateUnits.find((unit) => units.includes(unit));
+export function getMinDateUnit(units) {
+    return dateUnits.find((unit) => units.includes(unit));
 }
-function isValidDate(s) {
-  return relativeDate.test(s) || isValid(parseISO(s));
+export function isValidDate(s) {
+    return relativeDate.test(s) || isValid(parseISO(s));
 }
-export {
-  dateUnitMap,
-  dateUnits,
-  getMinDateUnit,
-  isValidDate,
-  parseDate
-};

package/dist/esm/utils/payments.js

@@ -1,29 +1,27 @@
-import { ContributionPeriod, PaymentMethod } from "../data/index.js";
+import { ContributionPeriod, PaymentMethod } from "../data";
 const stripeFees = {
-  gb: {
-    [PaymentMethod.StripeCard]: (amount) => 0.2 + 0.015 * amount,
-    [PaymentMethod.StripeSEPA]: () => 0.3,
-    [PaymentMethod.StripeBACS]: (amount) => Math.min(2, Math.max(0.2, 0.01 * amount))
-  },
-  eu: {
-    [PaymentMethod.StripeCard]: (amount) => 0.25 + 0.015 * amount,
-    [PaymentMethod.StripeSEPA]: () => 0.35,
-    [PaymentMethod.StripeBACS]: () => 0
-    // Not available
-  },
-  ca: {
-    [PaymentMethod.StripeCard]: (amount) => 0.3 + 0.029 * amount,
-    [PaymentMethod.StripeSEPA]: () => 0,
-    // Not available
-    [PaymentMethod.StripeBACS]: () => 0
-    // Not available
-  }
+    gb: {
+        [PaymentMethod.StripeCard]: (amount) => 0.2 + 0.015 * amount,
+        [PaymentMethod.StripeSEPA]: () => 0.3,
+        [PaymentMethod.StripeBACS]: (amount) => Math.min(2, Math.max(0.2, 0.01 * amount)),
+    },
+    eu: {
+        [PaymentMethod.StripeCard]: (amount) => 0.25 + 0.015 * amount,
+        [PaymentMethod.StripeSEPA]: () => 0.35,
+        [PaymentMethod.StripeBACS]: () => 0, // Not available
+    },
+    ca: {
+        [PaymentMethod.StripeCard]: (amount) => 0.3 + 0.029 * amount,
+        [PaymentMethod.StripeSEPA]: () => 0,
+        [PaymentMethod.StripeBACS]: () => 0, // Not available
+    },
 };
 const gcFee = (amount) => 0.2 + amount * 0.01;
-function calcPaymentFee(feeable, country) {
-  const feeFn = feeable.paymentMethod === PaymentMethod.GoCardlessDirectDebit ? gcFee : stripeFees[country][feeable.paymentMethod];
-  return feeable.period === ContributionPeriod.Annually ? 0 : feeFn(feeable.amount);
+export function calcPaymentFee(feeable, country) {
+    const feeFn = feeable.paymentMethod === PaymentMethod.GoCardlessDirectDebit
+        ? gcFee
+        : stripeFees[country][feeable.paymentMethod];
+    return feeable.period === ContributionPeriod.Annually
+        ? 0
+        : feeFn(feeable.amount);
 }
-export {
-  calcPaymentFee
-};

package/dist/esm/utils/rules.js

@@ -1,80 +1,63 @@
-import { InvalidRule } from "../error/index.js";
-import { nullableOperators, operatorsByTypeMap } from "../search/index.js";
-import { isValidDate } from "./date.js";
-function isRuleGroup(ruleOrGroup) {
-  return "condition" in ruleOrGroup;
+import { InvalidRule } from "../error";
+import { nullableOperators, operatorsByTypeMap, } from "../search";
+import { isValidDate } from "./date";
+export function isRuleGroup(ruleOrGroup) {
+    return "condition" in ruleOrGroup;
 }
-function validateRule(filters, rule) {
-  const filter = filters[rule.field];
-  if (!filter) {
-    throw new InvalidRule(rule, `Invalid field: ${rule.field}`);
-  }
-  let expectedArgs = 0;
-  if (rule.operator in nullableOperators) {
-    if (!filter.nullable && filter.type !== "text") {
-      throw new InvalidRule(
-        rule,
-        `Invalid nullable operator: field is not nullable`
-      );
+export function validateRule(filters, rule) {
+    const filter = filters[rule.field];
+    if (!filter) {
+        throw new InvalidRule(rule, `Invalid field: ${rule.field}`);
     }
-  } else {
-    const operator = operatorsByTypeMap[filter.type][rule.operator];
-    if (!operator) {
-      throw new InvalidRule(
-        rule,
-        `Invalid operator for type: ${filter.type} type doesn't define ${rule.operator}`
-      );
+    let expectedArgs = 0;
+    if (rule.operator in nullableOperators) {
+        // Field cannot be empty (except text which can always be empty)
+        if (!filter.nullable && filter.type !== "text") {
+            throw new InvalidRule(rule, `Invalid nullable operator: field is not nullable`);
+        }
     }
-    expectedArgs = operator.args;
-  }
-  if (expectedArgs !== rule.value.length) {
-    throw new InvalidRule(
-      rule,
-      `Invalid operator argument count: ${rule.operator} needs ${expectedArgs}, ${rule.value.length} given`
-    );
-  }
-  const expectedType = filter.type === "boolean" || filter.type === "number" ? filter.type : "string";
-  if (rule.value.some((v) => typeof v !== expectedType)) {
-    throw new InvalidRule(
-      rule,
-      `Invalid operator argument type: ${rule.operator} needs ${expectedType}, ${rule.value.map(
-        (v) => typeof v
-      )} given`
-    );
-  }
-  if (filter.type === "date" && rule.value.some((v) => !isValidDate(v))) {
-    throw new InvalidRule(
-      rule,
-      `Invalid operator argument: date type needs valid absolute or relative date, ${rule.value} given`
-    );
-  }
-  if ((filter.type === "enum" || filter.type === "array") && rule.value.some((v) => filter.options?.indexOf(v) === -1)) {
-    throw new InvalidRule(
-      rule,
-      `Invalid operator argument: ${filter.type} type expected ${filter.options}, ${rule.value} given`
-    );
-  }
-  return {
-    field: rule.field,
-    type: filter.type,
-    nullable: !!filter.nullable,
-    operator: rule.operator,
-    value: rule.value
-  };
+    else {
+        const operator = operatorsByTypeMap[filter.type][rule.operator];
+        if (!operator) {
+            throw new InvalidRule(rule, `Invalid operator for type: ${filter.type} type doesn't define ${rule.operator}`);
+        }
+        expectedArgs = operator.args;
+    }
+    if (expectedArgs !== rule.value.length) {
+        throw new InvalidRule(rule, `Invalid operator argument count: ${rule.operator} needs ${expectedArgs}, ${rule.value.length} given`);
+    }
+    const expectedType = filter.type === "boolean" || filter.type === "number"
+        ? filter.type
+        : "string";
+    if (rule.value.some((v) => typeof v !== expectedType)) {
+        throw new InvalidRule(rule, `Invalid operator argument type: ${rule.operator} needs ${expectedType}, ${rule.value.map((v) => typeof v)} given`);
+    }
+    if (filter.type === "date" &&
+        rule.value.some((v) => !isValidDate(v))) {
+        throw new InvalidRule(rule, `Invalid operator argument: date type needs valid absolute or relative date, ${rule.value} given`);
+    }
+    if ((filter.type === "enum" || filter.type === "array") &&
+        rule.value.some((v) => filter.options?.indexOf(v) === -1)) {
+        throw new InvalidRule(rule, `Invalid operator argument: ${filter.type} type expected ${filter.options}, ${rule.value} given`);
+    }
+    return {
+        field: rule.field,
+        type: filter.type,
+        nullable: !!filter.nullable,
+        operator: rule.operator,
+        value: rule.value,
+    };
 }
-function validateRuleGroup(filters, ruleGroup) {
-  const validatedRuleGroup = {
-    condition: ruleGroup.condition,
-    rules: []
-  };
-  for (const rule of ruleGroup.rules) {
-    const valid = isRuleGroup(rule) ? validateRuleGroup(filters, rule) : validateRule(filters, rule);
-    validatedRuleGroup.rules.push(valid);
-  }
-  return validatedRuleGroup;
+export function validateRuleGroup(filters, ruleGroup) {
+    const validatedRuleGroup = {
+        condition: ruleGroup.condition,
+        rules: [],
+    };
+    for (const rule of ruleGroup.rules) {
+        const valid = isRuleGroup(rule)
+            ? validateRuleGroup(filters, rule)
+            : validateRule(filters, rule);
+        validatedRuleGroup.rules.push(valid);
+    }
+    return validatedRuleGroup;
 }
-export {
-  isRuleGroup,
-  validateRule,
-  validateRuleGroup
-};