@beabee/beabee-common 1.8.1 → 1.8.3

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

@@ -16,3 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./search"), exports);
 __exportStar(require("./data"), exports);
+__exportStar(require("./error"), exports);
+__exportStar(require("./utils/date"), exports);
+__exportStar(require("./utils/rules"), exports);

package/dist/cjs/search/index.js

@@ -1,4 +1,5 @@
 "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);
@@ -13,14 +14,8 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 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);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertFiltersToRuleGroup = exports.convertRuleGroupToFilters = exports.validateRuleGroup = exports.validateRule = exports.InvalidRule = exports.isRuleGroup = exports.operatorsByType = exports.nullableOperators = exports.ruleOperators = void 0;
-const isValid_1 = __importDefault(require("date-fns/isValid"));
-const parseISO_1 = __importDefault(require("date-fns/parseISO"));
-// *** Definitions for rules ***
+exports.operatorsByTypeMap = exports.operatorsByType = exports.nullableOperators = exports.ruleOperators = void 0;
 exports.ruleOperators = [
     "equal",
     "not_equal",
@@ -39,6 +34,7 @@ exports.ruleOperators = [
     "is_empty",
     "is_not_empty",
 ];
+// *** Operator definitions ***
 const equalityOperators = {
     equal: { args: 1 },
     not_equal: { args: 1 },
@@ -78,98 +74,7 @@ exports.operatorsByType = {
     contact: equalityOperators,
 };
 // More general type to allow mapping while maintaining full type above
-const operatorsByTypeMap = exports.operatorsByType;
-// *** Helper methods ***
-function isRuleGroup(ruleOrGroup) {
-    return "condition" in ruleOrGroup;
-}
-exports.isRuleGroup = isRuleGroup;
-class InvalidRule extends Error {
-    constructor(rule, message) {
-        super();
-        this.rule = rule;
-        this.message = message;
-        Object.setPrototypeOf(this, InvalidRule.prototype);
-    }
-}
-exports.InvalidRule = InvalidRule;
-function validateRule(filters, rule) {
-    const filter = filters[rule.field];
-    if (!filter) {
-        throw new InvalidRule(rule, `Invalid field: ${rule.field}`);
-    }
-    if (rule.operator in exports.nullableOperators) {
-        // Field cannot be empty (except text which can always be empty)
-        if (!filter.nullable && filter.type !== "text") {
-            throw new InvalidRule(rule, `Invalid nullable operator: field is not nullable`);
-        }
-        if (rule.value.length !== 0) {
-            throw new InvalidRule(rule, `Invalid operator argument count: ${rule.operator} needs 0, ${rule.value.length} given`);
-        }
-    }
-    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}`);
-        }
-        if (operator.args !== rule.value.length) {
-            throw new InvalidRule(rule, `Invalid operator argument count: ${rule.operator} needs ${operator.args}, ${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) => !(0, isValid_1.default)((0, parseISO_1.default)(v)))) {
-        throw new InvalidRule(rule, `Invalid operator argument: date type needs valid absolute or relative date, ${rule.value} given`);
-    }
-    return {
-        ...rule,
-        type: filter.type,
-    };
-}
-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;
-function convertRuleGroupToFilters(ruleGroup) {
-    if (!ruleGroup) {
-        return null;
-    }
-    // TODO: how to handle groups?
-    const rulesWithoutGroups = ruleGroup.rules.filter((rule) => !isRuleGroup(rule));
-    return rulesWithoutGroups.map((rule) => ({
-        id: rule.field,
-        operator: rule.operator,
-        values: [...rule.value],
-    }));
-}
-exports.convertRuleGroupToFilters = convertRuleGroupToFilters;
-function convertFiltersToRuleGroup(matchType, filters) {
-    return {
-        condition: matchType === "all" ? "AND" : "OR",
-        rules: filters.map((filter) => ({
-            field: filter.id,
-            operator: filter.operator,
-            value: filter.values,
-        })),
-    };
-}
-exports.convertFiltersToRuleGroup = convertFiltersToRuleGroup;
+exports.operatorsByTypeMap = exports.operatorsByType;
 __exportStar(require("./callouts"), exports);
 __exportStar(require("./contacts"), exports);
 __exportStar(require("./notices"), exports);

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/rules.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertFiltersToRuleGroup = exports.convertRuleGroupToFilters = 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}`);
+    }
+    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`);
+        }
+        if (rule.value.length !== 0) {
+            throw new error_1.InvalidRule(rule, `Invalid operator argument count: ${rule.operator} needs 0, ${rule.value.length} given`);
+        }
+    }
+    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}`);
+        }
+        if (operator.args !== rule.value.length) {
+            throw new error_1.InvalidRule(rule, `Invalid operator argument count: ${rule.operator} needs ${operator.args}, ${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`);
+    }
+    return {
+        ...rule,
+        type: filter.type,
+    };
+}
+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;
+function convertRuleGroupToFilters(ruleGroup) {
+    if (!ruleGroup) {
+        return null;
+    }
+    // TODO: how to handle groups?
+    const rulesWithoutGroups = ruleGroup.rules.filter((rule) => !isRuleGroup(rule));
+    return rulesWithoutGroups.map((rule) => ({
+        id: rule.field,
+        operator: rule.operator,
+        values: [...rule.value],
+    }));
+}
+exports.convertRuleGroupToFilters = convertRuleGroupToFilters;
+function convertFiltersToRuleGroup(matchType, filters) {
+    return {
+        condition: matchType === "all" ? "AND" : "OR",
+        rules: filters.map((filter) => ({
+            field: filter.id,
+            operator: filter.operator,
+            value: filter.values,
+        })),
+    };
+}
+exports.convertFiltersToRuleGroup = convertFiltersToRuleGroup;

package/dist/esm/error/InvalidRule.js

@@ -0,0 +1,8 @@
+export default class InvalidRule extends Error {
+    constructor(rule, message) {
+        super();
+        this.rule = rule;
+        this.message = message;
+        Object.setPrototypeOf(this, InvalidRule.prototype);
+    }
+}

package/dist/esm/error/index.js

@@ -0,0 +1,2 @@
+import InvalidRule from "./InvalidRule";
+export { InvalidRule };

package/dist/esm/index.js

@@ -1,2 +1,5 @@
 export * from "./search";
 export * from "./data";
+export * from "./error";
+export * from "./utils/date";
+export * from "./utils/rules";

package/dist/esm/search/index.js

@@ -1,5 +1,3 @@
-import isValid from "date-fns/isValid";
-import parseISO from "date-fns/parseISO";
 // *** Definitions for rules ***
 export const ruleOperators = [
     "equal",
@@ -19,6 +17,7 @@ export const ruleOperators = [
     "is_empty",
     "is_not_empty",
 ];
+// *** Operator definitions ***
 const equalityOperators = {
     equal: { args: 1 },
     not_equal: { args: 1 },
@@ -58,92 +57,7 @@ export const operatorsByType = {
     contact: equalityOperators,
 };
 // More general type to allow mapping while maintaining full type above
-const operatorsByTypeMap = operatorsByType;
-// *** Helper methods ***
-export function isRuleGroup(ruleOrGroup) {
-    return "condition" in ruleOrGroup;
-}
-export class InvalidRule extends Error {
-    constructor(rule, message) {
-        super();
-        this.rule = rule;
-        this.message = message;
-        Object.setPrototypeOf(this, InvalidRule.prototype);
-    }
-}
-export function validateRule(filters, rule) {
-    const filter = filters[rule.field];
-    if (!filter) {
-        throw new InvalidRule(rule, `Invalid field: ${rule.field}`);
-    }
-    if (rule.operator in nullableOperators) {
-        // Field cannot be empty (except text which can always be empty)
-        if (!filter.nullable && filter.type !== "text") {
-            throw new InvalidRule(rule, `Invalid nullable operator: field is not nullable`);
-        }
-        if (rule.value.length !== 0) {
-            throw new InvalidRule(rule, `Invalid operator argument count: ${rule.operator} needs 0, ${rule.value.length} given`);
-        }
-    }
-    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}`);
-        }
-        if (operator.args !== rule.value.length) {
-            throw new InvalidRule(rule, `Invalid operator argument count: ${rule.operator} needs ${operator.args}, ${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) => !isValid(parseISO(v)))) {
-        throw new InvalidRule(rule, `Invalid operator argument: date type needs valid absolute or relative date, ${rule.value} given`);
-    }
-    return {
-        ...rule,
-        type: filter.type,
-    };
-}
-export 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;
-}
-export function convertRuleGroupToFilters(ruleGroup) {
-    if (!ruleGroup) {
-        return null;
-    }
-    // TODO: how to handle groups?
-    const rulesWithoutGroups = ruleGroup.rules.filter((rule) => !isRuleGroup(rule));
-    return rulesWithoutGroups.map((rule) => ({
-        id: rule.field,
-        operator: rule.operator,
-        values: [...rule.value],
-    }));
-}
-export function convertFiltersToRuleGroup(matchType, filters) {
-    return {
-        condition: matchType === "all" ? "AND" : "OR",
-        rules: filters.map((filter) => ({
-            field: filter.id,
-            operator: filter.operator,
-            value: filter.values,
-        })),
-    };
-}
+export const operatorsByTypeMap = operatorsByType;
 export * from "./callouts";
 export * from "./contacts";
 export * from "./notices";

package/dist/esm/utils/date.js

@@ -0,0 +1,68 @@
+import add from "date-fns/add";
+import isValid from "date-fns/isValid";
+import parseISO from "date-fns/parseISO";
+import startOfDay from "date-fns/startOfDay";
+import startOfHour from "date-fns/startOfHour";
+import startOfMinute from "date-fns/startOfMinute";
+import startOfMonth from "date-fns/startOfMonth";
+import startOfSecond from "date-fns/startOfSecond";
+import startOfYear from "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,
+    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;
+// 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
+export 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 = 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];
+}
+export function getMinDateUnit(units) {
+    return dateUnits.find((unit) => units.includes(unit));
+}
+export function isValidDate(s) {
+    return relativeDate.test(s) || isValid(parseISO(s));
+}

package/dist/esm/utils/rules.js

@@ -0,0 +1,79 @@
+import { InvalidRule } from "../error";
+import { nullableOperators, operatorsByTypeMap, } from "../search";
+import { isValidDate } from "./date";
+export function isRuleGroup(ruleOrGroup) {
+    return "condition" in ruleOrGroup;
+}
+export function validateRule(filters, rule) {
+    const filter = filters[rule.field];
+    if (!filter) {
+        throw new InvalidRule(rule, `Invalid field: ${rule.field}`);
+    }
+    if (rule.operator in nullableOperators) {
+        // Field cannot be empty (except text which can always be empty)
+        if (!filter.nullable && filter.type !== "text") {
+            throw new InvalidRule(rule, `Invalid nullable operator: field is not nullable`);
+        }
+        if (rule.value.length !== 0) {
+            throw new InvalidRule(rule, `Invalid operator argument count: ${rule.operator} needs 0, ${rule.value.length} given`);
+        }
+    }
+    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}`);
+        }
+        if (operator.args !== rule.value.length) {
+            throw new InvalidRule(rule, `Invalid operator argument count: ${rule.operator} needs ${operator.args}, ${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`);
+    }
+    return {
+        ...rule,
+        type: filter.type,
+    };
+}
+export 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;
+}
+export function convertRuleGroupToFilters(ruleGroup) {
+    if (!ruleGroup) {
+        return null;
+    }
+    // TODO: how to handle groups?
+    const rulesWithoutGroups = ruleGroup.rules.filter((rule) => !isRuleGroup(rule));
+    return rulesWithoutGroups.map((rule) => ({
+        id: rule.field,
+        operator: rule.operator,
+        values: [...rule.value],
+    }));
+}
+export function convertFiltersToRuleGroup(matchType, filters) {
+    return {
+        condition: matchType === "all" ? "AND" : "OR",
+        rules: filters.map((filter) => ({
+            field: filter.id,
+            operator: filter.operator,
+            value: filter.values,
+        })),
+    };
+}

package/dist/types/error/InvalidRule.d.ts

@@ -0,0 +1,6 @@
+import { Rule } from "../search";
+export default class InvalidRule extends Error {
+    readonly rule: Rule;
+    readonly message: string;
+    constructor(rule: Rule, message: string);
+}

package/dist/types/error/index.d.ts

@@ -0,0 +1,2 @@
+import InvalidRule from "./InvalidRule";
+export { InvalidRule };

package/dist/types/index.d.ts

@@ -1,2 +1,5 @@
 export * from "./search";
 export * from "./data";
+export * from "./error";
+export * from "./utils/date";
+export * from "./utils/rules";

package/dist/types/search/index.d.ts

@@ -25,11 +25,29 @@ export interface ValidatedRuleGroup<Field extends string> {
     rules: (ValidatedRuleGroup<Field> | ValidatedRule<Field>)[];
 }
 export declare type FilterType = "text" | "date" | "number" | "boolean" | "array" | "enum" | "contact";
-export declare type FilterValue = RuleValue;
-export declare type FilterOperator = RuleOperator;
 export interface FilterOperatorParams {
     args: number;
 }
+interface BaseFilterArgs {
+    type: FilterType;
+    nullable?: boolean;
+}
+export interface EnumFilterArgs<T extends readonly string[] = readonly string[]> extends BaseFilterArgs {
+    type: "enum";
+    options: T;
+}
+export interface OtherFilterArgs extends BaseFilterArgs {
+    type: Exclude<FilterType, "enum">;
+}
+export declare type FilterArgs = EnumFilterArgs | OtherFilterArgs;
+export declare type Filters<T extends string = string> = Record<T, FilterArgs>;
+export declare type FilterValue = RuleValue;
+export declare type FilterOperator = RuleOperator;
+export interface Filter {
+    id: string;
+    operator: FilterOperator;
+    values: FilterValue[];
+}
 export declare const nullableOperators: {
     is_empty: {
         args: number;
@@ -147,24 +165,7 @@ export declare const operatorsByType: {
         };
     };
 };
-interface BaseFilterArgs {
-    type: FilterType;
-    nullable?: boolean;
-}
-export interface EnumFilterArgs<T extends readonly string[] = readonly string[]> extends BaseFilterArgs {
-    type: "enum";
-    options: T;
-}
-export interface OtherFilterArgs extends BaseFilterArgs {
-    type: Exclude<FilterType, "enum">;
-}
-export declare type FilterArgs = EnumFilterArgs | OtherFilterArgs;
-export declare type Filters<T extends string = string> = Record<T, FilterArgs>;
-export interface Filter {
-    id: string;
-    operator: FilterOperator;
-    values: FilterValue[];
-}
+export declare const operatorsByTypeMap: Record<FilterType, Partial<Record<FilterOperator, FilterOperatorParams>>>;
 export interface Paginated<T> {
     items: T[];
     offset: number;
@@ -178,16 +179,6 @@ export interface PaginatedQuery {
     order?: "ASC" | "DESC";
     rules?: RuleGroup;
 }
-export declare function isRuleGroup(ruleOrGroup: Rule | RuleGroup): ruleOrGroup is RuleGroup;
-export declare class InvalidRule extends Error {
-    readonly rule: Rule;
-    readonly message: string;
-    constructor(rule: Rule, message: string);
-}
-export declare function validateRule<Field extends string>(filters: Filters<Field>, rule: Rule): ValidatedRule<Field>;
-export declare function validateRuleGroup<Field extends string>(filters: Filters<Field>, ruleGroup: RuleGroup): ValidatedRuleGroup<Field>;
-export declare function convertRuleGroupToFilters(ruleGroup?: RuleGroup): Filter[] | null;
-export declare function convertFiltersToRuleGroup(matchType: "all" | "any", filters: Filter[]): RuleGroup;
 export * from "./callouts";
 export * from "./contacts";
 export * from "./notices";

package/dist/types/utils/date.d.ts

@@ -0,0 +1,6 @@
+declare const dateUnits: readonly ["s", "m", "h", "d", "M", "y"];
+declare type DateUnit = typeof dateUnits[number];
+export declare function parseDate(value: string, now?: Date): [Date, DateUnit];
+export declare function getMinDateUnit(units: DateUnit[]): DateUnit | undefined;
+export declare function isValidDate(s: string): boolean;
+export {};

package/dist/types/utils/rules.d.ts

@@ -0,0 +1,6 @@
+import { Filter, Filters, Rule, RuleGroup, ValidatedRule, ValidatedRuleGroup } from "../search";
+export declare function isRuleGroup(ruleOrGroup: Rule | RuleGroup): ruleOrGroup is RuleGroup;
+export declare function validateRule<Field extends string>(filters: Filters<Field>, rule: Rule): ValidatedRule<Field>;
+export declare function validateRuleGroup<Field extends string>(filters: Filters<Field>, ruleGroup: RuleGroup): ValidatedRuleGroup<Field>;
+export declare function convertRuleGroupToFilters(ruleGroup?: RuleGroup): Filter[] | null;
+export declare function convertFiltersToRuleGroup(matchType: "all" | "any", filters: Filter[]): RuleGroup;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beabee/beabee-common",
-  "version": "1.8.1",
+  "version": "1.8.3",
   "description": "",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -9,8 +9,8 @@
     "dist/"
   ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "rimraf ./dist/ && tsc -p tsconfig.esm.json && tsc -p tsconfig.cjs.json && tsc -p tsconfig.types.json",
+    "test": "jest",
+    "build": "rimraf ./dist/ && tsc -p tsconfig.build.esm.json && tsc -p tsconfig.build.cjs.json && tsc -p tsconfig.build.types.json",
     "prepublishOnly": "npm run build"
   },
   "repository": {
@@ -25,8 +25,10 @@
   "homepage": "https://github.com/beabee-communityrm/beabee-common#readme",
   "devDependencies": {
     "@tsconfig/recommended": "^1.0.1",
+    "jest": "^29.3.0",
     "prettier": "^2.7.1",
     "rimraf": "^3.0.2",
+    "ts-jest": "^29.0.3",
     "typescript": "^4.8.4"
   },
   "dependencies": {