@beabee/beabee-common 0.0.2 → 0.20.0-alpha.2

package/dist/esm/utils/date.js

@@ -0,0 +1,84 @@
+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"
+};
+const startOf = {
+  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;
+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 = /* @__PURE__ */ new Date()) {
+  let date;
+  let units;
+  const relativeMatch = relativeDate.exec(value);
+  if (relativeMatch) {
+    date = now;
+    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];
+}
+function getMinDateUnit(units) {
+  return dateUnits.find((unit) => units.includes(unit));
+}
+function isValidDate(s) {
+  if (typeof s === "string") {
+    return relativeDate.test(s) || isValid(parseISO(s));
+  }
+  return isValid(s);
+}
+function isDateBetween(date, start, end) {
+  let valid = isValidDate(date);
+  if (start) {
+    start = typeof start === "string" ? parseISO(start) : start;
+    valid = valid && date >= start;
+  }
+  if (end) {
+    end = typeof end === "string" ? parseISO(end) : end;
+    valid = valid && date <= end;
+  }
+  return valid;
+}
+export {
+  dateUnitMap,
+  dateUnits,
+  getMinDateUnit,
+  isDateBetween,
+  isValidDate,
+  parseDate
+};

package/dist/esm/utils/index.js

@@ -0,0 +1,7 @@
+export * from "./callouts.js";
+export * from "./conversions.js";
+export * from "./date.js";
+export * from "./payments.js";
+export * from "./rules.js";
+export * from "./slug.js";
+export * from "./validations.js";

package/dist/esm/utils/payments.js

@@ -0,0 +1,29 @@
+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,
+    // Not available
+    [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 {
+  calcPaymentFee
+};

package/dist/esm/utils/rules.js

@@ -0,0 +1,80 @@
+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;
+}
+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`
+      );
+    }
+  } 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 {
+  isRuleGroup,
+  validateRule,
+  validateRuleGroup
+};