@beabee/beabee-common 1.19.6 → 1.19.7

package/dist/cjs/utils/callouts.js

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

package/dist/cjs/utils/date.js

@@ -1,77 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidDate = exports.getMinDateUnit = exports.parseDate = void 0;
-const add_1 = __importDefault(require("date-fns/add"));
-const isValid_1 = __importDefault(require("date-fns/isValid"));
-const parseISO_1 = __importDefault(require("date-fns/parseISO"));
-const startOfDay_1 = __importDefault(require("date-fns/startOfDay"));
-const startOfHour_1 = __importDefault(require("date-fns/startOfHour"));
-const startOfMinute_1 = __importDefault(require("date-fns/startOfMinute"));
-const startOfMonth_1 = __importDefault(require("date-fns/startOfMonth"));
-const startOfSecond_1 = __importDefault(require("date-fns/startOfSecond"));
-const startOfYear_1 = __importDefault(require("date-fns/startOfYear"));
-// Must be ordered from highest resolution to lowest (seconds to years)
-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_1.default,
-    M: startOfMonth_1.default,
-    d: startOfDay_1.default,
-    h: startOfHour_1.default,
-    m: startOfMinute_1.default,
-    s: startOfSecond_1.default,
-};
-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
-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 = (0, add_1.default)(date, { [dateUnitMap[unit]]: Number(delta) });
-                units.push(unit);
-            }
-        }
-        else {
-            units = ["d"];
-        }
-    }
-    else {
-        date = (0, parseISO_1.default)(value);
-        units = Object.entries(absoluteDate.exec(value)?.groups || {})
-            .filter(([_, n]) => !!n)
-            .map(([unit]) => unit);
-    }
-    const minUnit = getMinDateUnit(units) || "s";
-    return [startOf[minUnit](date), minUnit];
-}
-exports.parseDate = parseDate;
-function getMinDateUnit(units) {
-    return dateUnits.find((unit) => units.includes(unit));
-}
-exports.getMinDateUnit = getMinDateUnit;
-function isValidDate(s) {
-    return relativeDate.test(s) || (0, isValid_1.default)((0, parseISO_1.default)(s));
-}
-exports.isValidDate = isValidDate;

package/dist/cjs/utils/payments.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calcPaymentFee = void 0;
-const data_1 = require("../data");
-const stripeFees = {
-    gb: {
-        [data_1.PaymentMethod.StripeCard]: (amount) => 0.2 + 0.015 * amount,
-        [data_1.PaymentMethod.StripeSEPA]: () => 0.3,
-        [data_1.PaymentMethod.StripeBACS]: (amount) => Math.min(2, Math.max(0.2, 0.01 * amount)),
-    },
-    eu: {
-        [data_1.PaymentMethod.StripeCard]: (amount) => 0.25 + 0.015 * amount,
-        [data_1.PaymentMethod.StripeSEPA]: () => 0.35,
-        [data_1.PaymentMethod.StripeBACS]: () => 0, // Not available
-    },
-    ca: {
-        [data_1.PaymentMethod.StripeCard]: (amount) => 0.3 + 0.029 * amount,
-        [data_1.PaymentMethod.StripeSEPA]: () => 0,
-        [data_1.PaymentMethod.StripeBACS]: () => 0, // Not available
-    },
-};
-const gcFee = (amount) => 0.2 + amount * 0.01;
-function calcPaymentFee(feeable, country) {
-    const feeFn = feeable.paymentMethod === data_1.PaymentMethod.GoCardlessDirectDebit
-        ? gcFee
-        : stripeFees[country][feeable.paymentMethod];
-    return feeable.period === data_1.ContributionPeriod.Annually
-        ? 0
-        : feeFn(feeable.amount);
-}
-exports.calcPaymentFee = calcPaymentFee;

package/dist/cjs/utils/rules.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateRuleGroup = exports.validateRule = exports.isRuleGroup = void 0;
-const error_1 = require("../error");
-const search_1 = require("../search");
-const date_1 = require("./date");
-function isRuleGroup(ruleOrGroup) {
-    return "condition" in ruleOrGroup;
-}
-exports.isRuleGroup = isRuleGroup;
-function validateRule(filters, rule) {
-    const filter = filters[rule.field];
-    if (!filter) {
-        throw new error_1.InvalidRule(rule, `Invalid field: ${rule.field}`);
-    }
-    let expectedArgs = 0;
-    if (rule.operator in search_1.nullableOperators) {
-        // Field cannot be empty (except text which can always be empty)
-        if (!filter.nullable && filter.type !== "text") {
-            throw new error_1.InvalidRule(rule, `Invalid nullable operator: field is not nullable`);
-        }
-    }
-    else {
-        const operator = search_1.operatorsByTypeMap[filter.type][rule.operator];
-        if (!operator) {
-            throw new error_1.InvalidRule(rule, `Invalid operator for type: ${filter.type} type doesn't define ${rule.operator}`);
-        }
-        expectedArgs = operator.args;
-    }
-    if (expectedArgs !== rule.value.length) {
-        throw new error_1.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 error_1.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, date_1.isValidDate)(v))) {
-        throw new error_1.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 error_1.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,
-    };
-}
-exports.validateRule = validateRule;
-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;
-}
-exports.validateRuleGroup = validateRuleGroup;

package/dist/esm/data/callouts.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,70 +0,0 @@
-export interface BaseCalloutComponentSchema {
-    id: string;
-    type: string;
-    key: string;
-    label?: string;
-    input?: boolean;
-    adminOnly?: boolean;
-    [key: string]: unknown;
-}
-export interface NestableCalloutComponentSchema extends BaseCalloutComponentSchema {
-    type: "panel" | "well" | "tabs";
-    input: false;
-    components: CalloutComponentSchema[];
-}
-export interface InputCalloutComponentSchema extends BaseCalloutComponentSchema {
-    type: "address" | "button" | "checkbox" | "email" | "file" | "number" | "password" | "textfield" | "textarea";
-    input: true;
-}
-export interface SelectCalloutComponentSchema extends BaseCalloutComponentSchema {
-    type: "select";
-    input: true;
-    data: {
-        values: {
-            label: string;
-            value: string;
-        }[];
-    };
-}
-export interface RadioCalloutComponentSchema extends BaseCalloutComponentSchema {
-    type: "radio" | "selectboxes";
-    input: true;
-    values: {
-        label: string;
-        value: string;
-        nextSlideId: string;
-    }[];
-}
-export type CalloutComponentSchema = SelectCalloutComponentSchema | RadioCalloutComponentSchema | InputCalloutComponentSchema | NestableCalloutComponentSchema;
-export interface CalloutNavigationSchema {
-    prevText: string;
-    nextText: string;
-    nextSlideId: string;
-    submitText: string;
-}
-export interface CalloutSlideSchema {
-    id: string;
-    title: string;
-    components: CalloutComponentSchema[];
-    navigation: CalloutNavigationSchema;
-}
-export interface CalloutFormSchema {
-    slides: CalloutSlideSchema[];
-}
-export interface CalloutResponseAnswerAddress {
-    formatted_address: string;
-    geometry: {
-        location: {
-            lat: number;
-            lng: number;
-        };
-    };
-}
-export interface CalloutResponseAnswerFileUpload {
-    url: string;
-}
-export type CalloutResponseAnswer = string | boolean | number | null | undefined | Record<string, boolean> | CalloutResponseAnswerAddress | CalloutResponseAnswerFileUpload;
-/**
- * Answers are grouped by slide key: {[slideId]: {[componentKey]: answer | answer[]}}
- */
-export type CalloutResponseAnswers = Record<string, Record<string, CalloutResponseAnswer | CalloutResponseAnswer[]> | undefined>;