@beabee/beabee-common 0.21.1-alpha.2 → 0.44.2

package/src/utils/url.ts

@@ -0,0 +1,52 @@
+export const isAbsoluteUrl = (url: string): boolean =>
+  !!url && (isBlobUrl(url) || /^https?:\/\//i.test(url));
+
+export const isBlobUrl = (url: string): boolean =>
+  !!url && url.startsWith('blob:');
+
+/**
+ * Resolves an image URL to ensure it's absolute.
+ * If the provided URL is relative (and not a blob URL), it prepends the API base URL.
+ * Absolute URLs, blob URLs, or URLs already pointing to the API are returned as is.
+ * Returns an empty string if the input is not a valid string.
+ *
+ * @param url - The image URL to process (can be relative or absolute).
+ * @param apiBaseUrl - The base URL for API endpoints (e.g., '/api/1.0/').
+ * @param appBaseUrl - The base URL for the application (e.g., 'https://example.com').
+ * @param width - Optional width parameter for image resizing.
+ * @returns The resolved, absolute image URL or an empty string.
+ */
+export function resolveImageUrl(
+  url: string | URL,
+  apiBaseUrl: string,
+  appBaseUrl: string,
+  width?: number
+): string {
+  if (!url || typeof url !== 'string') {
+    return '';
+  }
+
+  let urlObj: URL;
+
+  if (isAbsoluteUrl(url)) {
+    urlObj = new URL(url);
+  } else if (url.startsWith('blob:')) {
+    return url;
+  } else if (url.startsWith(apiBaseUrl)) {
+    urlObj = new URL(url, appBaseUrl);
+  } else {
+    // Remove leading slash if present to avoid double slashes
+    const cleanUrl = url.startsWith('/') ? url.slice(1) : url;
+    // Remove trailing slash from apiBaseUrl if present
+    const cleanApiBaseUrl = apiBaseUrl.endsWith('/')
+      ? apiBaseUrl.slice(0, -1)
+      : apiBaseUrl;
+    urlObj = new URL(`${cleanApiBaseUrl}/${cleanUrl}`, appBaseUrl);
+  }
+
+  if (width) {
+    urlObj.searchParams.set('w', width.toString());
+  }
+
+  return urlObj.toString();
+}

package/src/utils/validations.ts

@@ -0,0 +1,273 @@
+import { ContributionPeriod } from '../data/index.js';
+import { slug } from './slug.js';
+
+/**
+ * Check if the value is a valid angle.
+ * @param value The value to check
+ */
+export const isAngle = (value: unknown, span = 180): value is number => {
+  return typeof value === 'number' && value >= span * -1 && value <= span;
+};
+
+/**
+ * Check if the value is a valid email address.
+ * @param value The value to check
+ * @param span The span of the angle
+ */
+export const isEmail = (value: unknown): value is string => {
+  if (typeof value !== 'string' || value.length === 0) {
+    return false;
+  }
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(value);
+};
+
+/**
+ * Check if the value is a valid longitude/latitude pair.
+ * @param value The value to check
+ */
+export const isLngLat = (value: unknown): value is [number, number] => {
+  if (!Array.isArray(value) || value.length !== 2) {
+    return false;
+  }
+  const [longitude, latitude] = value;
+
+  // Longitude should be between -180 and 180 and latitude should be between -90 and 90
+  if (!isAngle(longitude, 180) || !isAngle(latitude, 90)) {
+    return false;
+  }
+
+  return true;
+};
+
+/**
+ * Check if the value is a valid map bounds.
+ * @param value The value to check
+ */
+export const isMapBounds = (
+  value: unknown
+): value is [[number, number], [number, number]] => {
+  return Array.isArray(value) && value.length === 2 && value.every(isLngLat);
+};
+
+/**
+ * Check if the value is a valid password.
+ * @param value The value to check
+ */
+export const isPassword = (value: unknown): value is string => {
+  return (
+    typeof value === 'string' &&
+    value.length >= 8 &&
+    /[a-z]/.test(value) &&
+    /[A-Z]/.test(value) &&
+    /[0-9]/.test(value)
+  );
+};
+
+/**
+ * Check if the value is a valid period.
+ * @param value The value to check
+ */
+export const isPeriod = (value: unknown): value is ContributionPeriod => {
+  return (
+    value === ContributionPeriod.Monthly ||
+    value === ContributionPeriod.Annually
+  );
+};
+
+/**
+ * Check if the value is a valid slug.
+ * @param value The value to check
+ * @returns
+ */
+export const isSlug = (value: unknown): value is string => {
+  return typeof value === 'string' && value === slug(value);
+};
+
+/**
+ * Check if the value is one of the given types
+ * @param types The valid types
+ * @param value The value to check
+ */
+export function isType(
+  types: Array<
+    | 'string'
+    | 'number'
+    | 'bigint'
+    | 'boolean'
+    | 'symbol'
+    | 'undefined'
+    | 'object'
+    | 'function'
+  >,
+  value: unknown
+): boolean {
+  return types.includes(typeof value);
+}
+
+/**
+ * Check if the value is a valid URL string
+ * @param value The value to check
+ */
+export const isURL = (value: unknown): value is string => {
+  if (typeof value !== 'string' || !value.length) {
+    return false;
+  }
+  const urlRegex =
+    /^(https?:\/\/)([\da-z\-]+\.)+[a-z]{2,6}(:[0-9]{1,5})?([\/\w \.-]*)*\/?(\?[a-zA-Z0-9=&]*)?$/;
+  return urlRegex.test(value);
+};
+
+/**
+ * Check if the value is a valid number
+ * @param value The value to check
+ */
+export const isNumber = (value: unknown): value is number => {
+  return typeof value === 'number' && !isNaN(value);
+};
+
+export const isAmountOfMoney = (value: unknown): value is number => {
+  if (!isNumber(value) || value < 0) {
+    return false;
+  }
+
+  const decimalPart = value.toString().split('.')[1];
+  // If the amount of money has decimal
+  if (decimalPart && decimalPart.length > 2) {
+    return false;
+  }
+
+  return true;
+};
+
+/**
+ * Check if the value is a valid phone number with the following rules:
+ * * Only uses numbers
+ * * Optionally starts with a `+`
+ * * Maximal length is 15 characters
+ * * Minimal length is 5 characters
+ * Note: This method is very generalised to work for as many countries as possible
+ * and does not take into whitespace, brackets or other characters commonly used
+ * in telephone number notation. To remove these, use `toPhoneNumber` instead.
+ * @param value The value to check
+ */
+export const isPhoneNumber = (value: unknown): value is string => {
+  if (typeof value !== 'string' || !value.length) {
+    return false;
+  }
+  if (value.length > 15 || value.length < 5) {
+    return false;
+  }
+  const phoneRegex = /^(\+?[0-9])\d*$/;
+  return phoneRegex.test(value);
+};
+
+/**
+ * Check if the the pay fee value is correct for the given amount and period
+ *
+ * @param value The value to check
+ * @param amount The amount
+ * @param period The period
+ */
+export const isValidPayFee = (
+  value: unknown,
+  amount: unknown,
+  period: unknown
+): value is boolean => {
+  if (
+    typeof value !== 'boolean' ||
+    typeof amount !== 'number' ||
+    !isPeriod(period)
+  ) {
+    return false;
+  }
+
+  // Annual contributions don't pay a fee
+  if (value && period === ContributionPeriod.Annually) {
+    return false;
+  }
+  // £1 monthly contributions must pay fee
+  if (!value && period === ContributionPeriod.Monthly && amount === 1) {
+    return false;
+  }
+
+  return true;
+};
+
+export const isNumberInRange = (
+  value: unknown,
+  min?: number,
+  max?: number
+): boolean => {
+  if (!isNumber(value)) {
+    return false;
+  }
+
+  if (typeof min === 'number') {
+    if (value < min) {
+      return false;
+    }
+  }
+
+  if (typeof max === 'number') {
+    if (value > max) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+/**
+ * Checks if a value is a string and its length is in a range
+ * @param value The value to check
+ * @param minLength The minimum length
+ * @param maxLength The maximum length
+ */
+export const isTextInRange = (
+  value: unknown,
+  minLength = 0,
+  maxLength?: number
+): boolean => {
+  if (typeof value !== 'string') {
+    return false;
+  }
+
+  if (typeof minLength === 'number' && value.length < minLength) {
+    return false;
+  }
+
+  if (typeof maxLength === 'number' && value.length > maxLength) {
+    return false;
+  }
+
+  return true;
+};
+
+/**
+ * Checks if a value is a string and its word length is in a range
+ * @param value The value to check
+ * @param minWordLength The minimum word length
+ * @param maxWordLength The maximum word length
+ */
+export const isTextInWordRange = (
+  value: unknown,
+  minWordLength = 0,
+  maxWordLength?: number
+): boolean => {
+  if (typeof value !== 'string') {
+    return false;
+  }
+
+  const words = value.length > 0 ? value.split(' ') : [];
+
+  if (typeof minWordLength === 'number' && words.length < minWordLength) {
+    return false;
+  }
+
+  if (typeof maxWordLength === 'number' && words.length > maxWordLength) {
+    return false;
+  }
+
+  return true;
+};

package/src/validators/callout-component-content.validator.ts

@@ -0,0 +1,12 @@
+import type {
+  CalloutComponentContentSchema,
+  ValidatorCalloutComponent,
+} from '../types/index.js';
+
+export const calloutComponentContentValidator: ValidatorCalloutComponent<
+  CalloutComponentContentSchema,
+  unknown
+> = (_: CalloutComponentContentSchema, answer: unknown): boolean => {
+  // Content components have no answer, so answer should be falsy
+  return !answer;
+};

package/src/validators/callout-component-input-address.validator.ts

@@ -0,0 +1,16 @@
+import type {
+  CalloutComponentInputAddressSchema,
+  CalloutResponseAnswer,
+  ValidatorCalloutComponent,
+} from '../types/index.js';
+
+export const calloutComponentInputAddressValidator: ValidatorCalloutComponent<
+  CalloutComponentInputAddressSchema
+> = (
+  _schema: CalloutComponentInputAddressSchema,
+  _answer: CalloutResponseAnswer
+): boolean => {
+  throw new Error(
+    `[calloutComponentInputAddressValidator] Not implemented yet`
+  );
+};

package/src/validators/callout-component-input-checkbox.validator.ts

@@ -0,0 +1,14 @@
+import type {
+  CalloutComponentInputCheckboxSchema,
+  CalloutResponseAnswer,
+  ValidatorCalloutComponent,
+} from '../types/index.js';
+
+export const calloutComponentInputCheckboxValidator: ValidatorCalloutComponent<
+  CalloutComponentInputCheckboxSchema
+> = (
+  _schema: CalloutComponentInputCheckboxSchema,
+  answer: CalloutResponseAnswer
+): boolean => {
+  return typeof answer === 'boolean';
+};

package/src/validators/callout-component-input-currency.validator.ts

@@ -0,0 +1,15 @@
+import type {
+  CalloutComponentInputCurrencySchema,
+  CalloutResponseAnswer,
+  ValidatorCalloutComponent,
+} from '../types/index.js';
+import { isAmountOfMoney } from '../utils/index.js';
+
+export const calloutComponentInputCurrencyValidator: ValidatorCalloutComponent<
+  CalloutComponentInputCurrencySchema
+> = (
+  _schema: CalloutComponentInputCurrencySchema,
+  answer: CalloutResponseAnswer
+): boolean => {
+  return isAmountOfMoney(answer);
+};

package/src/validators/callout-component-input-date-time.validator.ts

@@ -0,0 +1,19 @@
+import type {
+  CalloutComponentInputDateTimeSchema,
+  CalloutResponseAnswer,
+  ValidatorCalloutComponent,
+} from '../types/index.js';
+import { isDateBetween } from '../utils/index.js';
+
+export const calloutComponentInputDateTimeValidator: ValidatorCalloutComponent<
+  CalloutComponentInputDateTimeSchema
+> = (
+  schema: CalloutComponentInputDateTimeSchema,
+  answer: CalloutResponseAnswer
+): boolean => {
+  if (typeof answer !== 'string') {
+    return false;
+  }
+
+  return isDateBetween(answer, schema.widget.minDate, schema.widget.maxDate);
+};

package/src/validators/callout-component-input-email.validator.ts

@@ -0,0 +1,15 @@
+import type {
+  CalloutComponentInputEmailSchema,
+  CalloutResponseAnswer,
+  ValidatorCalloutComponent,
+} from '../types/index.js';
+import { isEmail } from '../utils/index.js';
+
+export const calloutComponentInputEmailValidator: ValidatorCalloutComponent<
+  CalloutComponentInputEmailSchema
+> = (
+  _schema: CalloutComponentInputEmailSchema,
+  answer: CalloutResponseAnswer
+): boolean => {
+  return isEmail(answer);
+};

package/src/validators/callout-component-input-file.validator.ts

@@ -0,0 +1,22 @@
+import type {
+  CalloutComponentInputFileSchema,
+  CalloutResponseAnswer,
+  ValidatorCalloutComponent,
+} from '../types/index.js';
+import { isFileUploadAnswer } from '../utils/callouts.js';
+import { isURL } from '../utils/index.js';
+
+export const calloutComponentInputFileValidator: ValidatorCalloutComponent<
+  CalloutComponentInputFileSchema
+> = (
+  _schema: CalloutComponentInputFileSchema,
+  answer: CalloutResponseAnswer
+): boolean => {
+  // TODO: We just check the file URL at the moment, but we need to check the file size and type too
+
+  if (isFileUploadAnswer(answer)) {
+    return isURL(answer.url);
+  }
+
+  return false;
+};

package/src/validators/callout-component-input-number.validator.ts

@@ -0,0 +1,22 @@
+import type {
+  CalloutComponentInputNumberSchema,
+  CalloutResponseAnswer,
+  ValidatorCalloutComponent,
+} from '../types/index.js';
+import { isNumber, isNumberInRange } from '../utils/index.js';
+
+export const calloutComponentInputNumberValidator: ValidatorCalloutComponent<
+  CalloutComponentInputNumberSchema
+> = (
+  schema: CalloutComponentInputNumberSchema,
+  answer: CalloutResponseAnswer
+): boolean => {
+  if (
+    schema.validate &&
+    !isNumberInRange(answer, schema.validate.min, schema.validate.max)
+  ) {
+    return false;
+  }
+
+  return isNumber(answer);
+};

package/src/validators/callout-component-input-phone-number.validator.ts

@@ -0,0 +1,15 @@
+import type {
+  CalloutComponentInputPhoneNumberSchema,
+  CalloutResponseAnswer,
+  ValidatorCalloutComponent,
+} from '../types/index.js';
+import { isPhoneNumber } from '../utils/index.js';
+
+export const calloutComponentInputPhoneNumberValidator: ValidatorCalloutComponent<
+  CalloutComponentInputPhoneNumberSchema
+> = (
+  _schema: CalloutComponentInputPhoneNumberSchema,
+  answer: CalloutResponseAnswer
+): boolean => {
+  return isPhoneNumber(answer);
+};

package/src/validators/callout-component-input-select.validator.ts

@@ -0,0 +1,15 @@
+import type {
+  CalloutComponentInputSelectSchema,
+  CalloutResponseAnswer,
+  ValidatorCalloutComponent,
+} from '../types/index.js';
+
+export const calloutComponentInputSelectValidator: ValidatorCalloutComponent<
+  CalloutComponentInputSelectSchema
+> = (
+  schema: CalloutComponentInputSelectSchema,
+  answer: CalloutResponseAnswer
+): boolean => {
+  const optionValue = schema.data.values.find((v) => v.value === answer);
+  return !!optionValue;
+};

package/src/validators/callout-component-input-selectable.validator.ts

@@ -0,0 +1,15 @@
+import type {
+  CalloutComponentInputSelectableSchema,
+  CalloutResponseAnswer,
+  ValidatorCalloutComponent,
+} from '../types/index.js';
+
+export const calloutComponentInputSelectableValidator: ValidatorCalloutComponent<
+  CalloutComponentInputSelectableSchema
+> = (
+  schema: CalloutComponentInputSelectableSchema,
+  answer: CalloutResponseAnswer
+): boolean => {
+  const optionValue = schema.values.find((v) => v.value === answer);
+  return !!optionValue;
+};

package/src/validators/callout-component-input-signature.validator.ts

@@ -0,0 +1,16 @@
+import type {
+  CalloutComponentInputSignatureSchema,
+  CalloutResponseAnswer,
+  ValidatorCalloutComponent,
+} from '../types/index.js';
+
+export const calloutComponentInputSignatureValidator: ValidatorCalloutComponent<
+  CalloutComponentInputSignatureSchema
+> = (
+  _: CalloutComponentInputSignatureSchema,
+  _answer: CalloutResponseAnswer
+): boolean => {
+  throw new Error(
+    `[calloutComponentInputSignatureValidator] Not implemented yet`
+  );
+};

package/src/validators/callout-component-input-text.validator.ts

@@ -0,0 +1,56 @@
+import type {
+  CalloutComponentInputTextRules,
+  CalloutComponentInputTextSchema,
+  CalloutResponseAnswer,
+  ValidatorCalloutComponent,
+} from '../types/index.js';
+import { isTextInRange, isTextInWordRange } from '../utils/index.js';
+
+const validateRules = (
+  rules: CalloutComponentInputTextRules | undefined,
+  answer: string | undefined
+): boolean => {
+  // Nothing to do..
+  if (!rules) {
+    return true;
+  }
+
+  if (!answer && rules.required) {
+    return false;
+  }
+
+  // Check if the answer matches the provided pattern
+  if (
+    typeof rules.pattern === 'string' &&
+    rules.pattern.length &&
+    !new RegExp(rules.pattern).test(answer || '')
+  ) {
+    return false;
+  }
+
+  // Check word range if defined
+  if (!isTextInWordRange(answer, rules.minWords, rules.maxWords)) {
+    return false;
+  }
+
+  // Check length range if defined
+  if (!isTextInRange(answer, rules.minLength, rules.maxLength)) {
+    return false;
+  }
+
+  // If all checks pass, return true
+  return true;
+};
+
+export const calloutComponentInputTextValidator: ValidatorCalloutComponent<
+  CalloutComponentInputTextSchema
+> = (
+  schema: CalloutComponentInputTextSchema,
+  answer: CalloutResponseAnswer
+): boolean => {
+  if (typeof answer !== 'string') {
+    return false;
+  }
+
+  return validateRules(schema?.validate, answer);
+};

package/src/validators/callout-component-input-time.validator.ts

@@ -0,0 +1,14 @@
+import type {
+  CalloutComponentInputTimeSchema,
+  CalloutResponseAnswer,
+  ValidatorCalloutComponent,
+} from '../types/index.js';
+
+export const calloutComponentInputTimeValidator: ValidatorCalloutComponent<
+  CalloutComponentInputTimeSchema
+> = (
+  _schema: CalloutComponentInputTimeSchema,
+  _answer: CalloutResponseAnswer
+): boolean => {
+  throw new Error(`[calloutComponentInputTimeValidator] Not implemented yet`);
+};

package/src/validators/callout-component-input-url.validator.ts

@@ -0,0 +1,15 @@
+import type {
+  CalloutComponentInputUrlSchema,
+  CalloutResponseAnswer,
+  ValidatorCalloutComponent,
+} from '../types/index.js';
+import { isURL } from '../utils/index.js';
+
+export const calloutComponentInputUrlValidator: ValidatorCalloutComponent<
+  CalloutComponentInputUrlSchema
+> = (
+  _schema: CalloutComponentInputUrlSchema,
+  answer: CalloutResponseAnswer
+): boolean => {
+  return isURL(answer);
+};