@beabee/beabee-common 0.44.2 → 0.45.0

package/dist/esm/utils/callouts.js

@@ -1,157 +0,0 @@
-import {
-  CalloutComponentBaseType,
-  CalloutComponentType,
-  calloutComponentInputSelectableTypes,
-  calloutComponentInputTextTypes,
-  calloutComponentInputTypes,
-  calloutComponentNestableTypes
-} from "../data/index.js";
-function convertValuesToOptions(values) {
-  return values.map(({ value }) => value);
-}
-function convertComponentToFilter(component) {
-  const baseItem = {
-    label: component.label || component.fullKey,
-    nullable: true
-  };
-  if (isCalloutComponentOfType(component, CalloutComponentType.INPUT_CHECKBOX)) {
-    return { ...baseItem, type: "boolean", nullable: false };
-  }
-  if (isCalloutComponentOfType(component, CalloutComponentType.INPUT_NUMBER)) {
-    return { ...baseItem, type: "number" };
-  }
-  if (isCalloutComponentOfType(component, CalloutComponentType.INPUT_SELECT)) {
-    return {
-      ...baseItem,
-      type: "enum",
-      options: convertValuesToOptions(component.data.values)
-    };
-  }
-  if (isCalloutComponentOfBaseType(
-    component,
-    CalloutComponentBaseType.INPUT_SELECTABLE
-  )) {
-    return {
-      ...baseItem,
-      type: component.type === CalloutComponentType.INPUT_SELECTABLE_RADIO ? "enum" : "array",
-      options: convertValuesToOptions(component.values)
-    };
-  }
-  if (isCalloutComponentOfType(component, CalloutComponentType.INPUT_TEXT_AREA)) {
-    return { ...baseItem, type: "blob" };
-  }
-  return { ...baseItem, type: "text" };
-}
-function getSelectableLabelFromValue(component, value) {
-  if (isCalloutComponentOfBaseType(
-    component,
-    CalloutComponentBaseType.INPUT_SELECTABLE
-  )) {
-    return component.values.find((v) => v.value === value)?.label || value;
-  }
-  if (isCalloutComponentOfType(component, CalloutComponentType.INPUT_SELECT)) {
-    return component.data.values.find((v) => v.value === value)?.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 === CalloutComponentBaseType.CONTENT) {
-    return isCalloutComponentOfType(component, CalloutComponentType.CONTENT);
-  }
-  if (type === CalloutComponentBaseType.INPUT) {
-    return calloutComponentInputTypes.includes(component.type);
-  }
-  if (type === CalloutComponentBaseType.INPUT_TEXT) {
-    return calloutComponentInputTextTypes.includes(
-      component.type
-    );
-  }
-  if (type === CalloutComponentBaseType.INPUT_SELECTABLE) {
-    return calloutComponentInputSelectableTypes.includes(
-      component.type
-    );
-  }
-  if (type === CalloutComponentBaseType.NESTABLE) {
-    return calloutComponentNestableTypes.includes(component.type);
-  }
-  return false;
-}
-function flattenComponents(components) {
-  return components.flatMap(
-    (component) => isCalloutComponentOfBaseType(component, CalloutComponentBaseType.NESTABLE) ? [component, ...flattenComponents(component.components)] : [component]
-  );
-}
-function filterComponents(components, filterFn) {
-  return components.filter(filterFn).map((component) => {
-    return {
-      ...component,
-      ...isCalloutComponentOfBaseType(
-        component,
-        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 isFormioFileAnswer(answer) {
-  return !!answer && typeof answer === "object" && "url" in answer && "storage" in answer && "name" in answer && "size" 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 JSON.stringify(answer);
-  } 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();
-  }
-}
-function getByPath(obj, path) {
-  return path.split(".").reduce((acc, key) => acc && key in acc ? acc[key] : void 0, obj);
-}
-export {
-  filterComponents,
-  flattenComponents,
-  getByPath,
-  getCalloutComponents,
-  getCalloutFilters,
-  isAddressAnswer,
-  isCalloutComponentOfBaseType,
-  isCalloutComponentOfType,
-  isFileUploadAnswer,
-  isFormioFileAnswer,
-  stringifyAnswer
-};

package/dist/esm/utils/conversions.js

@@ -1,28 +0,0 @@
-import { isPhoneNumber } from "./validations.js";
-const toPhoneNumber = (value) => {
-  if (typeof value !== "string" || !value.length) {
-    return false;
-  }
-  const result = value.replace(/(?!^\+)\D/g, "");
-  if (!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);
-};
-export {
-  toBytes,
-  toPhoneNumber
-};

package/dist/esm/utils/date.js

@@ -1,84 +0,0 @@
-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/debounce.js

@@ -1,49 +0,0 @@
-function debounce(fn, wait) {
-  let timeoutId = null;
-  const debounced = function(...args) {
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
-    }
-    timeoutId = setTimeout(() => {
-      fn(...args);
-    }, wait);
-  };
-  debounced.cancel = () => {
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-    }
-  };
-  return debounced;
-}
-function throttle(fn, wait) {
-  let lastCallTime = 0;
-  let timeoutId = null;
-  const throttled = function(...args) {
-    const now = Date.now();
-    const timeSinceLastCall = now - lastCallTime;
-    if (timeSinceLastCall >= wait) {
-      lastCallTime = now;
-      fn(...args);
-    } else {
-      if (timeoutId !== null) {
-        clearTimeout(timeoutId);
-      }
-      timeoutId = setTimeout(() => {
-        lastCallTime = Date.now();
-        fn(...args);
-      }, wait - timeSinceLastCall);
-    }
-  };
-  throttled.cancel = () => {
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-    }
-  };
-  return throttled;
-}
-export {
-  debounce,
-  throttle
-};

package/dist/esm/utils/file.js

@@ -1,39 +0,0 @@
-import {
-  ALLOWED_DOCUMENT_EXTENSIONS,
-  ALLOWED_DOCUMENT_MIME_TYPES,
-  ALLOWED_IMAGE_EXTENSIONS,
-  ALLOWED_IMAGE_MIME_TYPES
-} from "../constants.js";
-const isSupportedDocumentType = (mimetype) => {
-  if (!mimetype) return false;
-  return ALLOWED_DOCUMENT_MIME_TYPES.includes(mimetype.toLowerCase().trim());
-};
-const isSupportedDocumentExtension = (extension) => {
-  if (!extension) return false;
-  return ALLOWED_DOCUMENT_EXTENSIONS.includes(extension.toLowerCase().trim());
-};
-const isSupportedImageType = (mimetype) => {
-  if (!mimetype) return false;
-  return ALLOWED_IMAGE_MIME_TYPES.includes(mimetype.toLowerCase().trim());
-};
-const isSupportedImageExtension = (extension) => {
-  if (!extension) return false;
-  return ALLOWED_IMAGE_EXTENSIONS.includes(extension.toLowerCase().trim());
-};
-const bytesToHumanReadable = (bytes) => {
-  const units = ["B", "KB", "MB", "GB", "TB"];
-  let index = 0;
-  let value = bytes;
-  while (value >= 1024 && index < units.length - 1) {
-    value /= 1024;
-    index++;
-  }
-  return `${value.toFixed(2)} ${units[index]}`;
-};
-export {
-  bytesToHumanReadable,
-  isSupportedDocumentExtension,
-  isSupportedDocumentType,
-  isSupportedImageExtension,
-  isSupportedImageType
-};

package/dist/esm/utils/index.js

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

package/dist/esm/utils/payments.js

@@ -1,46 +0,0 @@
-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)),
-    [PaymentMethod.StripePayPal]: (amount) => 0.1 + 0.02 * amount,
-    [PaymentMethod.StripeIdeal]: () => 0.3
-    // Becomes a SEPA so same fee
-  },
-  eu: {
-    [PaymentMethod.StripeCard]: (amount) => 0.25 + 0.015 * amount,
-    [PaymentMethod.StripeSEPA]: () => 0.35,
-    [PaymentMethod.StripeBACS]: () => 0,
-    // Not available
-    [PaymentMethod.StripePayPal]: (amount) => 0.1 + 0.02 * amount,
-    [PaymentMethod.StripeIdeal]: () => 0.35
-    // Becomes a SEPA so same fee
-  },
-  ca: {
-    [PaymentMethod.StripeCard]: (amount) => 0.3 + 0.029 * amount,
-    [PaymentMethod.StripeSEPA]: () => 0,
-    // Not available
-    [PaymentMethod.StripeBACS]: () => 0,
-    // Not available
-    [PaymentMethod.StripePayPal]: () => 0,
-    // Not available
-    [PaymentMethod.StripeIdeal]: () => 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];
-  if (!feeFn) {
-    const error = new Error(
-      `No fee function found for "${feeable.paymentMethod}" in "${country}". Please check that the payment methods have been configured correctly.`
-    );
-    console.error(error);
-    return 0;
-  }
-  return feeable.period === ContributionPeriod.Annually ? 0 : feeFn(feeable.amount);
-}
-export {
-  calcPaymentFee
-};

package/dist/esm/utils/rules.js

@@ -1,86 +0,0 @@
-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" && filter.type !== "array") {
-      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;
-}
-function flattenRules(ruleGroup) {
-  return ruleGroup.rules.flatMap(
-    (rule) => isRuleGroup(rule) ? flattenRules(rule) : rule
-  );
-}
-export {
-  flattenRules,
-  isRuleGroup,
-  validateRule,
-  validateRuleGroup
-};