@beabee/beabee-common 1.19.7 → 1.19.9

package/dist/cjs/data/callouts.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/data/index.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleTypes = exports.PaymentStatus = exports.PaymentMethod = exports.NewsletterStatus = exports.MembershipStatus = exports.ItemStatus = exports.ContributionType = exports.ContributionPeriod = void 0;
+var ContributionPeriod;
+(function (ContributionPeriod) {
+    ContributionPeriod["Monthly"] = "monthly";
+    ContributionPeriod["Annually"] = "annually";
+})(ContributionPeriod = exports.ContributionPeriod || (exports.ContributionPeriod = {}));
+var ContributionType;
+(function (ContributionType) {
+    ContributionType["Automatic"] = "Automatic";
+    ContributionType["Manual"] = "Manual";
+    ContributionType["Gift"] = "Gift";
+    ContributionType["None"] = "None";
+})(ContributionType = exports.ContributionType || (exports.ContributionType = {}));
+var ItemStatus;
+(function (ItemStatus) {
+    ItemStatus["Draft"] = "draft";
+    ItemStatus["Scheduled"] = "scheduled";
+    ItemStatus["Open"] = "open";
+    ItemStatus["Ended"] = "ended";
+})(ItemStatus = exports.ItemStatus || (exports.ItemStatus = {}));
+var MembershipStatus;
+(function (MembershipStatus) {
+    MembershipStatus["Active"] = "active";
+    MembershipStatus["Expiring"] = "expiring";
+    MembershipStatus["Expired"] = "expired";
+    MembershipStatus["None"] = "none";
+})(MembershipStatus = exports.MembershipStatus || (exports.MembershipStatus = {}));
+var NewsletterStatus;
+(function (NewsletterStatus) {
+    NewsletterStatus["Subscribed"] = "subscribed";
+    NewsletterStatus["Unsubscribed"] = "unsubscribed";
+    NewsletterStatus["Cleaned"] = "cleaned";
+    NewsletterStatus["Pending"] = "pending";
+    NewsletterStatus["None"] = "none";
+})(NewsletterStatus = exports.NewsletterStatus || (exports.NewsletterStatus = {}));
+var PaymentMethod;
+(function (PaymentMethod) {
+    PaymentMethod["StripeCard"] = "s_card";
+    PaymentMethod["StripeSEPA"] = "s_sepa";
+    PaymentMethod["StripeBACS"] = "s_bacs";
+    PaymentMethod["GoCardlessDirectDebit"] = "gc_direct-debit";
+})(PaymentMethod = exports.PaymentMethod || (exports.PaymentMethod = {}));
+var PaymentStatus;
+(function (PaymentStatus) {
+    PaymentStatus["Pending"] = "pending";
+    PaymentStatus["Successful"] = "successful";
+    PaymentStatus["Failed"] = "failed";
+    PaymentStatus["Cancelled"] = "cancelled";
+})(PaymentStatus = exports.PaymentStatus || (exports.PaymentStatus = {}));
+exports.RoleTypes = ["member", "admin", "superadmin"];
+__exportStar(require("./callouts"), exports);

package/dist/cjs/error/InvalidRule.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class InvalidRule extends Error {
+    constructor(rule, message) {
+        super();
+        this.rule = rule;
+        this.message = message;
+        Object.setPrototypeOf(this, InvalidRule.prototype);
+    }
+}
+exports.default = InvalidRule;

package/dist/cjs/error/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidRule = void 0;
+const InvalidRule_1 = __importDefault(require("./InvalidRule"));
+exports.InvalidRule = InvalidRule_1.default;

package/dist/cjs/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./search"), exports);
+__exportStar(require("./data"), exports);
+__exportStar(require("./error"), exports);
+__exportStar(require("./utils/callouts"), exports);
+__exportStar(require("./utils/date"), exports);
+__exportStar(require("./utils/payments"), exports);
+__exportStar(require("./utils/rules"), exports);

package/dist/cjs/search/api-keys.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiKeyFilters = void 0;
+exports.apiKeyFilters = {
+    id: {
+        type: "text",
+    },
+    createdAt: {
+        type: "date",
+    },
+};

package/dist/cjs/search/callouts.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calloutTagFilters = exports.calloutResponseCommentFilters = exports.calloutResponseFilters = exports.calloutFilters = void 0;
+const data_1 = require("../data");
+exports.calloutFilters = {
+    slug: {
+        type: "text",
+    },
+    title: {
+        type: "text",
+    },
+    status: {
+        type: "enum",
+        options: [
+            data_1.ItemStatus.Draft,
+            data_1.ItemStatus.Scheduled,
+            data_1.ItemStatus.Open,
+            data_1.ItemStatus.Ended,
+        ],
+    },
+    answeredBy: {
+        type: "contact",
+    },
+    starts: {
+        type: "date",
+        nullable: true,
+    },
+    expires: {
+        type: "date",
+        nullable: true,
+    },
+    hidden: {
+        type: "boolean",
+    },
+};
+exports.calloutResponseFilters = {
+    id: {
+        type: "text",
+    },
+    contact: {
+        type: "contact",
+        nullable: true,
+    },
+    callout: {
+        type: "text",
+    },
+    createdAt: {
+        type: "date",
+    },
+    updatedAt: {
+        type: "date",
+    },
+    bucket: {
+        type: "text",
+        nullable: true,
+    },
+    tags: {
+        type: "array",
+    },
+    assignee: {
+        type: "contact",
+        nullable: true,
+    },
+    answers: {
+        type: "blob",
+    },
+};
+exports.calloutResponseCommentFilters = {
+    id: {
+        type: "text",
+    },
+    responseId: {
+        type: "text",
+    },
+    contact: {
+        type: "contact",
+    },
+    createdAt: {
+        type: "date",
+    },
+    updatedAt: {
+        type: "date",
+    },
+    text: {
+        type: "text",
+    },
+};
+exports.calloutTagFilters = {
+    id: {
+        type: "text",
+    },
+    name: {
+        type: "text",
+    },
+    description: {
+        type: "text",
+    },
+    calloutSlug: {
+        type: "text",
+    },
+};

package/dist/cjs/search/contacts.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contactFilters = void 0;
+const data_1 = require("../data");
+exports.contactFilters = {
+    id: {
+        type: "contact",
+    },
+    firstname: {
+        type: "text",
+    },
+    lastname: {
+        type: "text",
+    },
+    email: {
+        type: "text",
+    },
+    joined: {
+        type: "date",
+    },
+    lastSeen: {
+        type: "date",
+    },
+    contributionCancelled: {
+        type: "date",
+        nullable: true,
+    },
+    contributionType: {
+        type: "enum",
+        options: [
+            data_1.ContributionType.Automatic,
+            data_1.ContributionType.Gift,
+            data_1.ContributionType.Manual,
+            data_1.ContributionType.None,
+        ],
+    },
+    contributionMonthlyAmount: {
+        type: "number",
+    },
+    contributionPeriod: {
+        type: "enum",
+        options: [data_1.ContributionPeriod.Monthly, data_1.ContributionPeriod.Annually],
+    },
+    deliveryOptIn: {
+        type: "boolean",
+    },
+    newsletterStatus: {
+        type: "enum",
+        options: [
+            data_1.NewsletterStatus.Subscribed,
+            data_1.NewsletterStatus.Unsubscribed,
+            data_1.NewsletterStatus.Cleaned,
+            data_1.NewsletterStatus.Pending,
+            data_1.NewsletterStatus.None,
+        ],
+    },
+    activePermission: {
+        type: "enum",
+        options: data_1.RoleTypes,
+    },
+    activeMembership: {
+        type: "boolean",
+    },
+    membershipStarts: {
+        type: "date",
+    },
+    membershipExpires: {
+        type: "date",
+    },
+    manualPaymentSource: {
+        type: "text",
+        nullable: true,
+    },
+    tags: {
+        type: "array",
+        nullable: true,
+    },
+};

package/dist/cjs/search/index.js

@@ -0,0 +1,81 @@
+"use strict";
+// *** Definitions for rules ***
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operatorsByTypeMap = exports.operatorsByType = exports.nullableOperators = exports.ruleOperators = void 0;
+exports.ruleOperators = [
+    "equal",
+    "not_equal",
+    "less",
+    "less_or_equal",
+    "greater",
+    "greater_or_equal",
+    "between",
+    "not_between",
+    "begins_with",
+    "not_begins_with",
+    "contains",
+    "not_contains",
+    "ends_with",
+    "not_ends_with",
+    "is_empty",
+    "is_not_empty",
+];
+const equalityOperators = {
+    equal: { args: 1 },
+    not_equal: { args: 1 },
+};
+const stringOperators = {
+    begins_with: { args: 1 },
+    ends_with: { args: 1 },
+    not_begins_with: { args: 1 },
+    not_ends_with: { args: 1 },
+};
+const numericOperators = {
+    ...equalityOperators,
+    between: { args: 2 },
+    not_between: { args: 2 },
+    less: { args: 1 },
+    greater: { args: 1 },
+    less_or_equal: { args: 1 },
+    greater_or_equal: { args: 1 },
+};
+const arrayOperators = {
+    contains: { args: 1 },
+    not_contains: { args: 1 },
+};
+// Special operator can be applied across all fields if they are nullable
+exports.nullableOperators = {
+    is_empty: { args: 0 },
+    is_not_empty: { args: 0 },
+};
+exports.operatorsByType = {
+    text: { ...equalityOperators, ...arrayOperators, ...stringOperators },
+    blob: arrayOperators,
+    date: numericOperators,
+    number: numericOperators,
+    boolean: { equal: equalityOperators.equal },
+    array: arrayOperators,
+    enum: equalityOperators,
+    contact: equalityOperators,
+};
+// More general type to allow mapping while maintaining full type above
+exports.operatorsByTypeMap = exports.operatorsByType;
+__exportStar(require("./api-keys"), exports);
+__exportStar(require("./callouts"), exports);
+__exportStar(require("./contacts"), exports);
+__exportStar(require("./notices"), exports);
+__exportStar(require("./payments"), exports);

package/dist/cjs/search/notices.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noticeFilters = void 0;
+const data_1 = require("../data");
+exports.noticeFilters = {
+    id: {
+        type: "text",
+    },
+    createdAt: {
+        type: "date",
+    },
+    updatedAt: {
+        type: "date",
+    },
+    name: {
+        type: "text",
+    },
+    expires: {
+        type: "date",
+        nullable: true,
+    },
+    enabled: {
+        type: "boolean",
+    },
+    text: {
+        type: "text",
+    },
+    status: {
+        type: "enum",
+        options: [
+            data_1.ItemStatus.Draft,
+            data_1.ItemStatus.Scheduled,
+            data_1.ItemStatus.Open,
+            data_1.ItemStatus.Ended,
+        ],
+    },
+};

package/dist/cjs/search/payments.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paymentFilters = void 0;
+const data_1 = require("../data");
+exports.paymentFilters = {
+    id: {
+        type: "text",
+    },
+    contact: {
+        type: "contact",
+    },
+    chargeDate: {
+        type: "date",
+    },
+    amount: {
+        type: "number",
+    },
+    status: {
+        type: "enum",
+        options: [
+            data_1.PaymentStatus.Successful,
+            data_1.PaymentStatus.Pending,
+            data_1.PaymentStatus.Failed,
+            data_1.PaymentStatus.Cancelled,
+        ],
+    },
+};

package/dist/cjs/utils/callouts.js

@@ -0,0 +1,118 @@
+"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

@@ -0,0 +1,77 @@
+"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

@@ -0,0 +1,31 @@
+"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;