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

package/dist/cjs/utils/callouts.cjs

@@ -0,0 +1,175 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var callouts_exports = {};
+__export(callouts_exports, {
+  filterComponents: () => filterComponents,
+  flattenComponents: () => flattenComponents,
+  getCalloutComponents: () => getCalloutComponents,
+  getCalloutFilters: () => getCalloutFilters,
+  isAddressAnswer: () => isAddressAnswer,
+  isCalloutComponentOfBaseType: () => isCalloutComponentOfBaseType,
+  isCalloutComponentOfType: () => isCalloutComponentOfType,
+  isFileUploadAnswer: () => isFileUploadAnswer,
+  stringifyAnswer: () => stringifyAnswer
+});
+module.exports = __toCommonJS(callouts_exports);
+var import_data = require("../data/index.cjs");
+function convertValuesToOptions(values) {
+  return values.map(({ value }) => value);
+}
+function convertComponentToFilter(component) {
+  const baseItem = {
+    label: component.label || component.fullKey,
+    nullable: true
+  };
+  if (isCalloutComponentOfType(component, import_data.CalloutComponentType.INPUT_CHECKBOX)) {
+    return { ...baseItem, type: "boolean", nullable: false };
+  }
+  if (isCalloutComponentOfType(component, import_data.CalloutComponentType.INPUT_NUMBER)) {
+    return { ...baseItem, type: "number" };
+  }
+  if (isCalloutComponentOfType(
+    component,
+    import_data.CalloutComponentType.INPUT_SELECT
+  )) {
+    return {
+      ...baseItem,
+      type: "enum",
+      options: convertValuesToOptions(component.data.values)
+    };
+  }
+  if (isCalloutComponentOfType(component, import_data.CalloutComponentType.INPUT_TEXT_AREA)) {
+    return { ...baseItem, type: "blob" };
+  }
+  return { ...baseItem, type: "text" };
+}
+function getSelectableLabelFromValue(component, value) {
+  var _a, _b;
+  if (isCalloutComponentOfBaseType(
+    component,
+    import_data.CalloutComponentBaseType.INPUT_SELECTABLE
+  )) {
+    return ((_a = component.values.find((v) => v.value === value)) == null ? void 0 : _a.label) || value;
+  }
+  if (isCalloutComponentOfType(component, import_data.CalloutComponentType.INPUT_SELECT)) {
+    return ((_b = component.data.values.find((v) => v.value === value)) == null ? void 0 : _b.label) || value;
+  }
+  return value;
+}
+function isCalloutComponentOfType(component, type) {
+  return "type" in component && component.type === type;
+}
+function isCalloutComponentOfBaseType(component, type) {
+  if (!("type" in component)) {
+    return false;
+  }
+  if (type === import_data.CalloutComponentBaseType.CONTENT) {
+    return isCalloutComponentOfType(
+      component,
+      import_data.CalloutComponentType.CONTENT
+    );
+  }
+  if (type === import_data.CalloutComponentBaseType.INPUT) {
+    return import_data.calloutComponentInputTypes.includes(
+      component.type
+    );
+  }
+  if (type === import_data.CalloutComponentBaseType.INPUT_TEXT) {
+    return import_data.calloutComponentInputTextTypes.includes(
+      component.type
+    );
+  }
+  if (type === import_data.CalloutComponentBaseType.INPUT_SELECTABLE) {
+    return import_data.calloutComponentInputSelectableTypes.includes(
+      component.type
+    );
+  }
+  if (type === import_data.CalloutComponentBaseType.NESTABLE) {
+    return import_data.calloutComponentNestableTypes.includes(
+      component.type
+    );
+  }
+  return false;
+}
+function flattenComponents(components) {
+  return components.flatMap(
+    (component) => isCalloutComponentOfBaseType(component, import_data.CalloutComponentBaseType.NESTABLE) ? [component, ...flattenComponents(component.components)] : [component]
+  );
+}
+function filterComponents(components, filterFn) {
+  return components.filter(filterFn).map((component) => {
+    return {
+      ...component,
+      ...isCalloutComponentOfBaseType(
+        component,
+        import_data.CalloutComponentBaseType.NESTABLE
+      ) && {
+        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}`
+    }))
+  );
+}
+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;
+}
+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]) => getSelectableLabelFromValue(component, value)).join(", ");
+  } else if (typeof answer === "string") {
+    return getSelectableLabelFromValue(component, answer);
+  } else {
+    return answer.toString();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  filterComponents,
+  flattenComponents,
+  getCalloutComponents,
+  getCalloutFilters,
+  isAddressAnswer,
+  isCalloutComponentOfBaseType,
+  isCalloutComponentOfType,
+  isFileUploadAnswer,
+  stringifyAnswer
+});

package/dist/cjs/utils/conversions.cjs

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var conversions_exports = {};
+__export(conversions_exports, {
+  toBytes: () => toBytes,
+  toPhoneNumber: () => toPhoneNumber
+});
+module.exports = __toCommonJS(conversions_exports);
+var import_validations = require("./validations.cjs");
+const toPhoneNumber = (value) => {
+  if (typeof value !== "string" || !value.length) {
+    return false;
+  }
+  const result = value.replace(/(?!^\+)\D/g, "");
+  if (!(0, import_validations.isPhoneNumber)(result)) {
+    return false;
+  }
+  return result;
+};
+const toBytes = (value) => {
+  if (typeof value !== "string" || !value.length) {
+    return null;
+  }
+  const lowerCase = value.toLowerCase();
+  const units = ["b", "kb", "mb", "gb", "tb", "pb", "eb", "zb", "yb"];
+  const [, num, unit] = lowerCase.match(/(\d+)(\w+)/);
+  const unitIndex = units.indexOf(unit.toLowerCase());
+  if (unitIndex === -1) {
+    return null;
+  }
+  return Number(num) * Math.pow(1024, unitIndex);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toBytes,
+  toPhoneNumber
+});

package/dist/cjs/utils/date.cjs

@@ -0,0 +1,104 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var date_exports = {};
+__export(date_exports, {
+  dateUnitMap: () => dateUnitMap,
+  dateUnits: () => dateUnits,
+  getMinDateUnit: () => getMinDateUnit,
+  isDateBetween: () => isDateBetween,
+  isValidDate: () => isValidDate,
+  parseDate: () => parseDate
+});
+module.exports = __toCommonJS(date_exports);
+var import_date_fns = require("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: import_date_fns.startOfYear,
+  M: import_date_fns.startOfMonth,
+  d: import_date_fns.startOfDay,
+  h: import_date_fns.startOfHour,
+  m: import_date_fns.startOfMinute,
+  s: import_date_fns.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()) {
+  var _a, _b;
+  let date;
+  let units;
+  const relativeMatch = relativeDate.exec(value);
+  if (relativeMatch) {
+    date = now;
+    const unitsGroup = (_a = relativeMatch.groups) == null ? void 0 : _a.units;
+    if (unitsGroup) {
+      const unitMatches = unitsGroup.matchAll(relativeUnit);
+      units = [];
+      for (const [_, unit, delta] of unitMatches) {
+        date = (0, import_date_fns.add)(date, { [dateUnitMap[unit]]: Number(delta) });
+        units.push(unit);
+      }
+    } else {
+      units = ["d"];
+    }
+  } else {
+    date = (0, import_date_fns.parseISO)(value);
+    units = Object.entries(((_b = absoluteDate.exec(value)) == null ? void 0 : _b.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) || (0, import_date_fns.isValid)((0, import_date_fns.parseISO)(s));
+  }
+  return (0, import_date_fns.isValid)(s);
+}
+function isDateBetween(date, start, end) {
+  let valid = isValidDate(date);
+  if (start) {
+    start = typeof start === "string" ? (0, import_date_fns.parseISO)(start) : start;
+    valid = valid && date >= start;
+  }
+  if (end) {
+    end = typeof end === "string" ? (0, import_date_fns.parseISO)(end) : end;
+    valid = valid && date <= end;
+  }
+  return valid;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dateUnitMap,
+  dateUnits,
+  getMinDateUnit,
+  isDateBetween,
+  isValidDate,
+  parseDate
+});

package/dist/cjs/utils/index.cjs

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./callouts.cjs"), module.exports);
+__reExport(utils_exports, require("./conversions.cjs"), module.exports);
+__reExport(utils_exports, require("./date.cjs"), module.exports);
+__reExport(utils_exports, require("./payments.cjs"), module.exports);
+__reExport(utils_exports, require("./rules.cjs"), module.exports);
+__reExport(utils_exports, require("./slug.cjs"), module.exports);
+__reExport(utils_exports, require("./validations.cjs"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./callouts.cjs"),
+  ...require("./conversions.cjs"),
+  ...require("./date.cjs"),
+  ...require("./payments.cjs"),
+  ...require("./rules.cjs"),
+  ...require("./slug.cjs"),
+  ...require("./validations.cjs")
+});

package/dist/cjs/utils/payments.cjs

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var payments_exports = {};
+__export(payments_exports, {
+  calcPaymentFee: () => calcPaymentFee
+});
+module.exports = __toCommonJS(payments_exports);
+var import_data = require("../data/index.cjs");
+const stripeFees = {
+  gb: {
+    [import_data.PaymentMethod.StripeCard]: (amount) => 0.2 + 0.015 * amount,
+    [import_data.PaymentMethod.StripeSEPA]: () => 0.3,
+    [import_data.PaymentMethod.StripeBACS]: (amount) => Math.min(2, Math.max(0.2, 0.01 * amount))
+  },
+  eu: {
+    [import_data.PaymentMethod.StripeCard]: (amount) => 0.25 + 0.015 * amount,
+    [import_data.PaymentMethod.StripeSEPA]: () => 0.35,
+    [import_data.PaymentMethod.StripeBACS]: () => 0
+    // Not available
+  },
+  ca: {
+    [import_data.PaymentMethod.StripeCard]: (amount) => 0.3 + 0.029 * amount,
+    [import_data.PaymentMethod.StripeSEPA]: () => 0,
+    // Not available
+    [import_data.PaymentMethod.StripeBACS]: () => 0
+    // Not available
+  }
+};
+const gcFee = (amount) => 0.2 + amount * 0.01;
+function calcPaymentFee(feeable, country) {
+  const feeFn = feeable.paymentMethod === import_data.PaymentMethod.GoCardlessDirectDebit ? gcFee : stripeFees[country][feeable.paymentMethod];
+  return feeable.period === import_data.ContributionPeriod.Annually ? 0 : feeFn(feeable.amount);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calcPaymentFee
+});

package/dist/cjs/utils/rules.cjs

@@ -0,0 +1,109 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rules_exports = {};
+__export(rules_exports, {
+  isRuleGroup: () => isRuleGroup,
+  validateRule: () => validateRule,
+  validateRuleGroup: () => validateRuleGroup
+});
+module.exports = __toCommonJS(rules_exports);
+var import_error = require("../error/index.cjs");
+var import_search = require("../search/index.cjs");
+var import_date = require("./date.cjs");
+function isRuleGroup(ruleOrGroup) {
+  return "condition" in ruleOrGroup;
+}
+function validateRule(filters, rule) {
+  const filter = filters[rule.field];
+  if (!filter) {
+    throw new import_error.InvalidRule(rule, `Invalid field: ${rule.field}`);
+  }
+  let expectedArgs = 0;
+  if (rule.operator in import_search.nullableOperators) {
+    if (!filter.nullable && filter.type !== "text") {
+      throw new import_error.InvalidRule(
+        rule,
+        `Invalid nullable operator: field is not nullable`
+      );
+    }
+  } else {
+    const operator = import_search.operatorsByTypeMap[filter.type][rule.operator];
+    if (!operator) {
+      throw new import_error.InvalidRule(
+        rule,
+        `Invalid operator for type: ${filter.type} type doesn't define ${rule.operator}`
+      );
+    }
+    expectedArgs = operator.args;
+  }
+  if (expectedArgs !== rule.value.length) {
+    throw new import_error.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 import_error.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) => !(0, import_date.isValidDate)(v))) {
+    throw new import_error.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) => {
+    var _a;
+    return ((_a = filter.options) == null ? void 0 : _a.indexOf(v)) === -1;
+  })) {
+    throw new import_error.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isRuleGroup,
+  validateRule,
+  validateRuleGroup
+});