@beabee/beabee-common 1.19.6 → 1.19.7

package/dist/esm/utils/callouts.js

@@ -1,108 +1,106 @@
 function isNestableComponent(component) {
-    // Addresses have embedded components we don't want to include
-    return "components" in component && component.type !== "address";
+  return "components" in component && component.type !== "address";
 }
 function convertValuesToOptions(values) {
-    return values.map(({ value, label }) => value);
+  return values.map(({ value }) => 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;
+  }
 }
-export function flattenComponents(components) {
-    return components.flatMap((component) => isNestableComponent(component)
-        ? [component, ...flattenComponents(component.components)]
-        : [component]);
+function flattenComponents(components) {
+  return components.flatMap(
+    (component) => isNestableComponent(component) ? [component, ...flattenComponents(component.components)] : [component]
+  );
 }
-export function filterComponents(components, filterFn) {
-    return components.filter(filterFn).map((component) => {
-        return {
-            ...component,
-            ...(isNestableComponent(component) && {
-                components: filterComponents(component.components, filterFn),
-            }),
-        };
-    });
+function filterComponents(components, filterFn) {
+  return components.filter(filterFn).map((component) => {
+    return {
+      ...component,
+      ...isNestableComponent(component) && {
+        components: filterComponents(component.components, filterFn)
+      }
+    };
+  });
 }
-export function getCalloutComponents(formSchema) {
-    return formSchema.slides.flatMap((slide) => flattenComponents(slide.components).map((component) => ({
-        ...component,
-        slideId: slide.id,
-        fullKey: `${slide.id}.${component.key}`,
-    })));
+function getCalloutComponents(formSchema) {
+  return formSchema.slides.flatMap(
+    (slide) => flattenComponents(slide.components).map((component) => ({
+      ...component,
+      slideId: slide.id,
+      fullKey: `${slide.id}.${component.key}`
+    }))
+  );
 }
-export function getCalloutFilters(formSchema) {
-    const items = getCalloutComponents(formSchema)
-        .filter((c) => c.input)
-        .map((c) => [`answers.${c.fullKey}`, convertComponentToFilter(c)]);
-    return Object.fromEntries(items);
+function getCalloutFilters(formSchema) {
+  const items = getCalloutComponents(formSchema).filter((c) => c.input).map((c) => [`answers.${c.fullKey}`, convertComponentToFilter(c)]);
+  return Object.fromEntries(items);
 }
-export function isAddressAnswer(answer) {
-    return !!answer && typeof answer === "object" && "geometry" in answer;
+function isAddressAnswer(answer) {
+  return !!answer && typeof answer === "object" && "geometry" in answer;
 }
-export function isFileUploadAnswer(answer) {
-    return !!answer && typeof answer === "object" && "url" in answer;
+function isFileUploadAnswer(answer) {
+  return !!answer && typeof answer === "object" && "url" in answer;
 }
-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();
-    }
+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 {
+  filterComponents,
+  flattenComponents,
+  getCalloutComponents,
+  getCalloutFilters,
+  isAddressAnswer,
+  isFileUploadAnswer,
+  stringifyAnswer
+};

package/dist/esm/utils/date.js

@@ -1,68 +1,68 @@
-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)
+import {
+  add,
+  isValid,
+  parseISO,
+  startOfDay,
+  startOfHour,
+  startOfMinute,
+  startOfMonth,
+  startOfSecond,
+  startOfYear
+} from "date-fns";
 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))?)?)?)?)?/;
-// 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"];
-        }
+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"];
     }
-    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];
 }
-export function getMinDateUnit(units) {
-    return dateUnits.find((unit) => units.includes(unit));
+function getMinDateUnit(units) {
+  return dateUnits.find((unit) => units.includes(unit));
 }
-export function isValidDate(s) {
-    return relativeDate.test(s) || isValid(parseISO(s));
+function isValidDate(s) {
+  return relativeDate.test(s) || isValid(parseISO(s));
 }
+export {
+  dateUnitMap,
+  dateUnits,
+  getMinDateUnit,
+  isValidDate,
+  parseDate
+};

package/dist/esm/utils/index.js

@@ -0,0 +1,4 @@
+export * from "./callouts.js";
+export * from "./date.js";
+export * from "./payments.js";
+export * from "./rules.js";

package/dist/esm/utils/payments.js

@@ -1,27 +1,29 @@
-import { ContributionPeriod, PaymentMethod } from "../data";
+import { ContributionPeriod, PaymentMethod } from "../data/index.js";
 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,
-        [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,
+    // Not available
+    [PaymentMethod.StripeBACS]: () => 0
+    // Not available
+  }
 };
 const gcFee = (amount) => 0.2 + amount * 0.01;
-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);
+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,63 +1,80 @@
-import { InvalidRule } from "../error";
-import { nullableOperators, operatorsByTypeMap, } from "../search";
-import { isValidDate } from "./date";
-export function isRuleGroup(ruleOrGroup) {
-    return "condition" in ruleOrGroup;
+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;
 }
-export function validateRule(filters, rule) {
-    const filter = filters[rule.field];
-    if (!filter) {
-        throw new InvalidRule(rule, `Invalid field: ${rule.field}`);
+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`
+      );
     }
-    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`);
-        }
+  } 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}`
+      );
     }
-    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,
-    };
+    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
+  };
 }
-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;
+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
+};

package/dist/types/data/index.d.ts

@@ -39,7 +39,3 @@ export declare enum PaymentStatus {
     Failed = "failed",
     Cancelled = "cancelled"
 }
-export declare const RoleTypes: readonly ["member", "admin", "superadmin"];
-export type RoleType = (typeof RoleTypes)[number];
-export type StripeFeeCountry = "eu" | "gb" | "ca";
-export * from "./callouts";

package/dist/types/error/InvalidRule.d.ts

@@ -1,5 +1,5 @@
-import { Rule } from "../search";
-export default class InvalidRule extends Error {
+import { Rule } from "../types/index.ts";
+export declare class InvalidRule extends Error {
     readonly rule: Rule;
     readonly message: string;
     constructor(rule: Rule, message: string);

package/dist/types/error/index.d.ts

@@ -1,2 +1 @@
-import InvalidRule from "./InvalidRule";
-export { InvalidRule };
+export * from "./InvalidRule.ts";

package/dist/types/index.d.ts

@@ -1,7 +1,5 @@
-export * from "./search";
-export * from "./data";
-export * from "./error";
-export * from "./utils/callouts";
-export * from "./utils/date";
-export * from "./utils/payments";
-export * from "./utils/rules";
+export * from "./data/index.ts";
+export * from "./error/index.ts";
+export * from "./search/index.ts";
+export * from "./utils/index.ts";
+export type * from "./types/index.ts";

package/dist/types/search/api-keys.d.ts

@@ -6,4 +6,3 @@ export declare const apiKeyFilters: {
         readonly type: "date";
     };
 };
-export type ApiKeyFilterName = keyof typeof apiKeyFilters;

package/dist/types/search/callouts.d.ts

@@ -1,4 +1,4 @@
-import { ItemStatus } from "../data";
+import { ItemStatus } from "../data/index.ts";
 export declare const calloutFilters: {
     readonly slug: {
         readonly type: "text";
@@ -25,7 +25,6 @@ export declare const calloutFilters: {
         readonly type: "boolean";
     };
 };
-export type CalloutFilterName = keyof typeof calloutFilters;
 export declare const calloutResponseFilters: {
     readonly id: {
         readonly type: "text";
@@ -58,7 +57,6 @@ export declare const calloutResponseFilters: {
         readonly type: "blob";
     };
 };
-export type CalloutResponseFilterName = keyof typeof calloutResponseFilters;
 export declare const calloutResponseCommentFilters: {
     readonly id: {
         readonly type: "text";
@@ -79,7 +77,6 @@ export declare const calloutResponseCommentFilters: {
         readonly type: "text";
     };
 };
-export type CalloutResponseCommentFilterName = keyof typeof calloutResponseCommentFilters;
 export declare const calloutTagFilters: {
     readonly id: {
         readonly type: "text";
@@ -94,4 +91,3 @@ export declare const calloutTagFilters: {
         readonly type: "text";
     };
 };
-export type CalloutTagFilterName = keyof typeof calloutTagFilters;

package/dist/types/search/contacts.d.ts

@@ -1,4 +1,5 @@
-import { ContributionPeriod, ContributionType, NewsletterStatus } from "../data";
+import { ContributionPeriod, ContributionType, NewsletterStatus } from "../data/index.ts";
+export declare const RoleTypes: readonly ["member", "admin", "superadmin"];
 export declare const contactFilters: {
     readonly id: {
         readonly type: "contact";