@dizmo/dcs-client-library 4.2.3 → 4.2.4

package/dist/index.d.ts

@@ -10,3 +10,4 @@ export { needs } from "./modules/needs";
 export { packages } from "./modules/packages";
 export { translations } from "./modules/translations";
 export { components } from "./modules/components";
+export { filterLogic } from "./modules/filterLogic";

package/dist/index.js

@@ -14,3 +14,4 @@ export { needs } from "./modules/needs";
 export { packages } from "./modules/packages";
 export { translations } from "./modules/translations";
 export { components } from "./modules/components";
+export { filterLogic } from "./modules/filterLogic";

package/dist/modules/filterLogic.d.ts

@@ -0,0 +1,30 @@
+import type { Filter, OperatorKey, OperatorDef, FilterCondition, AttrCategory } from "../types/types.js";
+declare function getCategory(attrType: string): AttrCategory;
+declare function getOperatorDefs(attrType: string): OperatorDef[];
+declare function getDefaultOperator(attrType: string): OperatorKey;
+declare function fieldPath(attributeId: string): string;
+declare function stripFieldPath(path: string): string;
+declare function coerceValue(raw: string, attrType: string): string | number | boolean | null;
+declare function formatDatetimeLocal(value: number): string;
+declare function buildFilterFromCondition(condition: FilterCondition, attrType: string): Filter | null;
+declare function buildFilter(conditions: FilterCondition[], attrTypes: Record<string, string>): Filter | null;
+declare function parseFilter(filter: Filter, attrTypes: Record<string, string>): FilterCondition[];
+declare function decomposeFilter(filter: Filter): Map<string, Filter>;
+declare function composeFilter(attrFilters: Map<string, Filter | null>): Filter | null;
+declare function assertExhaustive(x: never, message?: string): never;
+export declare const filterLogic: {
+    getCategory: typeof getCategory;
+    getOperatorDefs: typeof getOperatorDefs;
+    getDefaultOperator: typeof getDefaultOperator;
+    buildFilterFromCondition: typeof buildFilterFromCondition;
+    buildFilter: typeof buildFilter;
+    parseFilter: typeof parseFilter;
+    decomposeFilter: typeof decomposeFilter;
+    composeFilter: typeof composeFilter;
+    coerceValue: typeof coerceValue;
+    fieldPath: typeof fieldPath;
+    stripFieldPath: typeof stripFieldPath;
+    formatDatetimeLocal: typeof formatDatetimeLocal;
+    assertExhaustive: typeof assertExhaustive;
+};
+export {};

package/dist/modules/filterLogic.js

@@ -0,0 +1,582 @@
+// ─── Category mapping ────────────────────────────────────────────
+function getCategory(attrType) {
+    switch (attrType) {
+        case "integer":
+        case "float":
+        case "number":
+        case "slider":
+        case "stars":
+        case "datetime":
+            return "numeric";
+        case "string":
+        case "text":
+        case "heading1":
+        case "url":
+        case "email":
+        case "phone":
+        case "markdown":
+            return "text";
+        case "color":
+            return "color";
+        case "image_url":
+        case "document_url":
+            return "existence";
+        case "date":
+            return "date";
+        case "checkbox":
+            return "boolean";
+        case "selectbox":
+        case "radiobuttons":
+            return "select";
+        case "multi_selectbox":
+        case "multi_checkbox":
+        case "tags":
+            return "multi";
+        case "user":
+            return "user";
+        case "location":
+            return "skip";
+        default:
+            return "text";
+    }
+}
+// ─── Operator definitions ────────────────────────────────────────
+const CATEGORY_OPERATORS = {
+    numeric: [
+        { key: "equals", labelKey: "js_op-equals", labelFallback: "Equals", valueCount: 1 },
+        { key: "notEquals", labelKey: "js_op-is-not", labelFallback: "Is Not", valueCount: 1 },
+        { key: "greater", labelKey: "js_op-greater-than", labelFallback: "Greater Than", valueCount: 1 },
+        { key: "greaterOrEqual", labelKey: "js_op-greater-or-equal", labelFallback: "Greater or Equal", valueCount: 1 },
+        { key: "less", labelKey: "js_op-less-than", labelFallback: "Less Than", valueCount: 1 },
+        { key: "lessOrEqual", labelKey: "js_op-less-or-equal", labelFallback: "Less or Equal", valueCount: 1 },
+        { key: "between", labelKey: "js_op-between", labelFallback: "Between", valueCount: 2 },
+        { key: "notBetween", labelKey: "js_op-not-between", labelFallback: "Not Between", valueCount: 2 },
+        { key: "empty", labelKey: "js_op-is-empty", labelFallback: "Is Empty", valueCount: 0 },
+        { key: "notEmpty", labelKey: "js_op-is-not-empty", labelFallback: "Is Not Empty", valueCount: 0 },
+    ],
+    text: [
+        { key: "equals", labelKey: "js_op-equals", labelFallback: "Equals", valueCount: 1 },
+        { key: "notEquals", labelKey: "js_op-is-not", labelFallback: "Is Not", valueCount: 1 },
+        { key: "stringContains", labelKey: "js_op-contains", labelFallback: "Contains", valueCount: 1 },
+        { key: "startsWith", labelKey: "js_op-starts-with", labelFallback: "Starts With", valueCount: 1 },
+        { key: "endsWith", labelKey: "js_op-ends-with", labelFallback: "Ends With", valueCount: 1 },
+        { key: "empty", labelKey: "js_op-is-empty", labelFallback: "Is Empty", valueCount: 0 },
+        { key: "notEmpty", labelKey: "js_op-is-not-empty", labelFallback: "Is Not Empty", valueCount: 0 },
+    ],
+    date: [
+        { key: "equals", labelKey: "js_op-equals", labelFallback: "Equals", valueCount: 1 },
+        { key: "notEquals", labelKey: "js_op-is-not", labelFallback: "Is Not", valueCount: 1 },
+        { key: "greater", labelKey: "js_op-after", labelFallback: "After", valueCount: 1 },
+        { key: "greaterOrEqual", labelKey: "js_op-on-or-after", labelFallback: "On or After", valueCount: 1 },
+        { key: "less", labelKey: "js_op-before", labelFallback: "Before", valueCount: 1 },
+        { key: "lessOrEqual", labelKey: "js_op-on-or-before", labelFallback: "On or Before", valueCount: 1 },
+        { key: "between", labelKey: "js_op-between", labelFallback: "Between", valueCount: 2 },
+        { key: "notBetween", labelKey: "js_op-not-between", labelFallback: "Not Between", valueCount: 2 },
+        { key: "empty", labelKey: "js_op-is-not-selected", labelFallback: "Is Not Selected", valueCount: 0 },
+        { key: "notEmpty", labelKey: "js_op-is-selected", labelFallback: "Is Selected", valueCount: 0 },
+    ],
+    boolean: [
+        { key: "is_true", labelKey: "js_op-is-true", labelFallback: "Is True", valueCount: 0 },
+        { key: "is_false", labelKey: "js_op-is-false", labelFallback: "Is False", valueCount: 0 },
+        { key: "defined", labelKey: "js_op-is-defined", labelFallback: "Is Defined", valueCount: 0 },
+        { key: "undefined", labelKey: "js_op-is-not-defined", labelFallback: "Is Not Defined", valueCount: 0 },
+    ],
+    select: [
+        { key: "equals", labelKey: "js_op-equals", labelFallback: "Equals", valueCount: 1 },
+        { key: "notEquals", labelKey: "js_op-is-not", labelFallback: "Is Not", valueCount: 1 },
+        { key: "empty", labelKey: "js_op-is-not-selected", labelFallback: "Is Not Selected", valueCount: 0 },
+        { key: "notEmpty", labelKey: "js_op-is-selected", labelFallback: "Is Selected", valueCount: 0 },
+    ],
+    multi: [
+        { key: "arrayContains", labelKey: "js_op-contains", labelFallback: "Contains", valueCount: 1 },
+        { key: "notArrayContains", labelKey: "js_op-not-has", labelFallback: "Not Has", valueCount: 1 },
+        { key: "length", labelKey: "js_op-length", labelFallback: "Length", valueCount: 1 },
+        { key: "empty", labelKey: "js_op-is-not-selected", labelFallback: "Is Not Selected", valueCount: 0 },
+        { key: "notEmpty", labelKey: "js_op-is-selected", labelFallback: "Is Selected", valueCount: 0 },
+    ],
+    user: [
+        { key: "equals", labelKey: "js_op-equals", labelFallback: "Equals", valueCount: 1 },
+        { key: "notEquals", labelKey: "js_op-is-not", labelFallback: "Is Not", valueCount: 1 },
+    ],
+    existence: [
+        { key: "notEmpty", labelKey: "js_op-exists", labelFallback: "Exists", valueCount: 0 },
+        { key: "empty", labelKey: "js_op-does-not-exist", labelFallback: "Does not Exist", valueCount: 0 },
+    ],
+    color: [
+        { key: "equals", labelKey: "js_op-equals", labelFallback: "Equals", valueCount: 1 },
+        { key: "notEquals", labelKey: "js_op-is-not", labelFallback: "Is Not", valueCount: 1 },
+        { key: "notEmpty", labelKey: "js_op-exists", labelFallback: "Exists", valueCount: 0 },
+        { key: "empty", labelKey: "js_op-does-not-exist", labelFallback: "Does not Exist", valueCount: 0 },
+    ],
+    skip: [],
+};
+// Per-type overrides where a type diverges from its category
+const TYPE_OVERRIDES = {
+    slider: CATEGORY_OPERATORS.numeric.filter((op) => op.key !== "empty" && op.key !== "notEmpty"),
+    radiobuttons: CATEGORY_OPERATORS.select.filter((op) => op.key !== "empty" && op.key !== "notEmpty"),
+};
+function getOperatorDefs(attrType) {
+    if (attrType in TYPE_OVERRIDES)
+        return TYPE_OVERRIDES[attrType];
+    return CATEGORY_OPERATORS[getCategory(attrType)];
+}
+// ─── Default operators ───────────────────────────────────────────
+const DEFAULT_OPERATOR = {
+    string: "stringContains",
+    text: "stringContains",
+    heading1: "stringContains",
+    phone: "stringContains",
+    url: "stringContains",
+    email: "stringContains",
+    markdown: "stringContains",
+    number: "between",
+    integer: "between",
+    float: "between",
+    datetime: "between",
+    date: "between",
+    slider: "between",
+    checkbox: "is_true",
+    selectbox: "equals",
+    radiobuttons: "equals",
+    multi_checkbox: "arrayContains",
+    multi_selectbox: "arrayContains",
+    tags: "arrayContains",
+    color: "equals",
+    user: "equals",
+    image_url: "notEmpty",
+    document_url: "notEmpty",
+    stars: "equals",
+};
+function getDefaultOperator(attrType) {
+    return DEFAULT_OPERATOR[attrType] ?? "equals";
+}
+// ─── Path helpers ────────────────────────────────────────────────
+function fieldPath(attributeId) {
+    return `attributes.${attributeId}`;
+}
+function stripFieldPath(path) {
+    return path.startsWith("attributes.") ? path.slice("attributes.".length) : path;
+}
+// ─── Value helpers ───────────────────────────────────────────────
+function coerceValue(raw, attrType) {
+    const cat = getCategory(attrType);
+    if (cat === "numeric") {
+        if (attrType === "datetime" && raw)
+            return +new Date(raw);
+        return raw === "" ? 0 : Number(raw);
+    }
+    return raw;
+}
+function formatDatetimeLocal(value) {
+    const d = new Date(value);
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}T${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+// ─── Build filter from a single condition ────────────────────────
+function buildFilterFromCondition(condition, attrType) {
+    const path = fieldPath(condition.attributeId);
+    const op = condition.operator;
+    const cat = getCategory(attrType);
+    const raw1 = condition.values[0] ?? "";
+    const raw2 = condition.values[1] ?? "";
+    const val1 = coerceValue(raw1, attrType);
+    const val2 = coerceValue(raw2, attrType);
+    switch (op) {
+        case "equals":
+            return { equals: [path, val1] };
+        case "greater":
+            return { greater: [path, val1] };
+        case "greaterOrEqual":
+            return { greaterOrEqual: [path, val1] };
+        case "less":
+            return { less: [path, val1] };
+        case "lessOrEqual":
+            return { lessOrEqual: [path, val1] };
+        case "between":
+            return {
+                and: [
+                    { greaterOrEqual: [path, val1] },
+                    { lessOrEqual: [path, val2] },
+                ],
+            };
+        case "notBetween":
+            return {
+                not: {
+                    and: [
+                        { greaterOrEqual: [path, val1] },
+                        { lessOrEqual: [path, val2] },
+                    ],
+                },
+            };
+        case "stringContains":
+            return { stringContains: [path, String(val1)] };
+        case "startsWith":
+            return { startsWith: [path, String(val1)] };
+        case "endsWith":
+            return { endsWith: [path, String(val1)] };
+        case "arrayContains":
+            return { arrayContains: [path, val1] };
+        case "notArrayContains":
+            return { not: { arrayContains: [path, val1] } };
+        case "length":
+            return { length: [path, Number(val1) || 0] };
+        case "notEquals":
+            return { not: { equals: [path, val1] } };
+        case "empty":
+            if (cat === "multi")
+                return { length: [path, 0] };
+            return { equals: [path, ""] };
+        case "notEmpty":
+            if (cat === "multi")
+                return { not: { length: [path, 0] } };
+            return { not: { equals: [path, ""] } };
+        case "is_true":
+            return { equals: [path, true] };
+        case "is_false":
+            return { equals: [path, false] };
+        case "defined":
+            return { or: [{ equals: [path, true] }, { equals: [path, false] }] };
+        case "undefined":
+            return { not: { or: [{ equals: [path, true] }, { equals: [path, false] }] } };
+        default:
+            return null;
+    }
+}
+// ─── Build composed filter from multiple conditions ──────────────
+function buildFilter(conditions, attrTypes) {
+    const parts = [];
+    for (const cond of conditions) {
+        const attrType = attrTypes[cond.attributeId];
+        if (!attrType)
+            continue;
+        const f = buildFilterFromCondition(cond, attrType);
+        if (f !== null)
+            parts.push(f);
+    }
+    if (parts.length === 0)
+        return null;
+    if (parts.length === 1)
+        return parts[0];
+    return { and: parts };
+}
+// ─── Parse filter → conditions ───────────────────────────────────
+function parseFilter(filter, attrTypes) {
+    if (filter === null || filter === undefined)
+        return [];
+    let conditions;
+    if (typeof filter === "object" && "and" in filter) {
+        conditions = filter.and;
+    }
+    else {
+        conditions = [filter];
+    }
+    const result = [];
+    const consumed = new Set();
+    for (let i = 0; i < conditions.length; i++) {
+        if (consumed.has(i))
+            continue;
+        const cond = conditions[i];
+        if (cond === null || cond === undefined)
+            continue;
+        // Detect "between" sibling form: greaterOrEqual + lessOrEqual on same field
+        if (typeof cond === "object" && "greaterOrEqual" in cond) {
+            const [path, val1] = cond.greaterOrEqual;
+            const pairIdx = conditions.findIndex((c, j) => j > i &&
+                !consumed.has(j) &&
+                c !== null &&
+                c !== undefined &&
+                typeof c === "object" &&
+                "lessOrEqual" in c &&
+                c.lessOrEqual[0] === path);
+            if (pairIdx !== -1) {
+                const pair = conditions[pairIdx];
+                consumed.add(pairIdx);
+                const attrId = stripFieldPath(path);
+                const attrType = attrTypes[attrId];
+                result.push({
+                    attributeId: attrId,
+                    operator: "between",
+                    values: [
+                        formatValueForRestore(val1, attrType),
+                        formatValueForRestore(pair.lessOrEqual[1], attrType),
+                    ],
+                });
+                continue;
+            }
+        }
+        // Detect "between" nested form: { and: [{ greaterOrEqual: ... }, { lessOrEqual: ... }] }
+        if (typeof cond === "object" && "and" in cond) {
+            const children = cond.and;
+            const ge = children.find((f) => f !== null && typeof f === "object" && "greaterOrEqual" in f);
+            const le = children.find((f) => f !== null && typeof f === "object" && "lessOrEqual" in f);
+            if (ge && le && ge.greaterOrEqual[0] === le.lessOrEqual[0]) {
+                const attrId = stripFieldPath(ge.greaterOrEqual[0]);
+                const attrType = attrTypes[attrId];
+                result.push({
+                    attributeId: attrId,
+                    operator: "between",
+                    values: [
+                        formatValueForRestore(ge.greaterOrEqual[1], attrType),
+                        formatValueForRestore(le.lessOrEqual[1], attrType),
+                    ],
+                });
+                continue;
+            }
+            // Multi arrayContains nested form: { and: [{ arrayContains: ... }, ...] }
+            if (children.length > 0 &&
+                children.every((f) => f !== null && typeof f === "object" && "arrayContains" in f)) {
+                const first = children[0];
+                const attrId = stripFieldPath(first.arrayContains[0]);
+                // Each child is a separate arrayContains condition
+                for (const child of children) {
+                    const ac = child;
+                    result.push({
+                        attributeId: attrId,
+                        operator: "arrayContains",
+                        values: [String(ac.arrayContains[1])],
+                    });
+                }
+                continue;
+            }
+        }
+        // Simple comparison operators
+        const simpleKeys = [
+            "equals",
+            "greater",
+            "greaterOrEqual",
+            "less",
+            "lessOrEqual",
+            "stringContains",
+            "startsWith",
+            "endsWith",
+            "arrayContains",
+            "length",
+        ];
+        let matched = false;
+        for (const key of simpleKeys) {
+            if (typeof cond !== "object" || !(key in cond))
+                continue;
+            matched = true;
+            const [path, val] = cond[key];
+            const attrId = stripFieldPath(path);
+            const attrType = attrTypes[attrId];
+            const cat = attrType ? getCategory(attrType) : "text";
+            // Boolean: equals true/false → is_true/is_false
+            if (key === "equals" && cat === "boolean") {
+                result.push({
+                    attributeId: attrId,
+                    operator: val ? "is_true" : "is_false",
+                    values: [],
+                });
+                break;
+            }
+            // Empty: equals "" or null → empty
+            if (key === "equals" && (val === "" || val === null)) {
+                result.push({ attributeId: attrId, operator: "empty", values: [] });
+                break;
+            }
+            // Empty: length 0 on multi → empty
+            if (key === "length" && val === 0 && cat === "multi") {
+                result.push({ attributeId: attrId, operator: "empty", values: [] });
+                break;
+            }
+            result.push({
+                attributeId: attrId,
+                operator: key,
+                values: [formatValueForRestore(val, attrType)],
+            });
+            break;
+        }
+        if (matched)
+            continue;
+        // not → notEquals, notEmpty, notArrayContains, notBetween, undefined
+        if (typeof cond === "object" && "not" in cond) {
+            const inner = cond.not;
+            if (!inner || typeof inner !== "object")
+                continue;
+            if ("equals" in inner) {
+                const [path, val] = inner.equals;
+                const attrId = stripFieldPath(path);
+                if (val === "" || val === null) {
+                    result.push({ attributeId: attrId, operator: "notEmpty", values: [] });
+                }
+                else {
+                    const attrType = attrTypes[attrId];
+                    result.push({
+                        attributeId: attrId,
+                        operator: "notEquals",
+                        values: [formatValueForRestore(val, attrType)],
+                    });
+                }
+                continue;
+            }
+            if ("length" in inner) {
+                const [path] = inner.length;
+                result.push({ attributeId: stripFieldPath(path), operator: "notEmpty", values: [] });
+                continue;
+            }
+            if ("arrayContains" in inner) {
+                const [path, val] = inner.arrayContains;
+                result.push({
+                    attributeId: stripFieldPath(path),
+                    operator: "notArrayContains",
+                    values: [String(val)],
+                });
+                continue;
+            }
+            if ("and" in inner) {
+                const items = inner.and;
+                const ge = items.find((f) => f !== null && typeof f === "object" && "greaterOrEqual" in f);
+                const le = items.find((f) => f !== null && typeof f === "object" && "lessOrEqual" in f);
+                if (ge && le) {
+                    const attrId = stripFieldPath(ge.greaterOrEqual[0]);
+                    const attrType = attrTypes[attrId];
+                    result.push({
+                        attributeId: attrId,
+                        operator: "notBetween",
+                        values: [
+                            formatValueForRestore(ge.greaterOrEqual[1], attrType),
+                            formatValueForRestore(le.lessOrEqual[1], attrType),
+                        ],
+                    });
+                }
+                else if (items.length > 0 &&
+                    items.every((f) => f !== null && typeof f === "object" && "arrayContains" in f)) {
+                    // notArrayContains multi-value: { not: { and: [arrayContains, ...] } }
+                    const first = items[0];
+                    const attrId = stripFieldPath(first.arrayContains[0]);
+                    for (const child of items) {
+                        const ac = child;
+                        result.push({
+                            attributeId: attrId,
+                            operator: "notArrayContains",
+                            values: [String(ac.arrayContains[1])],
+                        });
+                    }
+                }
+                continue;
+            }
+            if ("or" in inner) {
+                const items = inner.or;
+                if (items.length === 2) {
+                    const eq1 = items.find((f) => f !== null && typeof f === "object" && "equals" in f && f.equals[1] === true);
+                    const eq2 = items.find((f) => f !== null && typeof f === "object" && "equals" in f && f.equals[1] === false);
+                    if (eq1 && eq2) {
+                        result.push({
+                            attributeId: stripFieldPath(eq1.equals[0]),
+                            operator: "undefined",
+                            values: [],
+                        });
+                    }
+                }
+                continue;
+            }
+            continue;
+        }
+        // or: [equals true, equals false] → defined
+        if (typeof cond === "object" && "or" in cond) {
+            const items = cond.or;
+            if (items.length === 2) {
+                const eq1 = items.find((f) => f !== null && typeof f === "object" && "equals" in f && f.equals[1] === true);
+                const eq2 = items.find((f) => f !== null && typeof f === "object" && "equals" in f && f.equals[1] === false);
+                if (eq1 && eq2) {
+                    result.push({
+                        attributeId: stripFieldPath(eq1.equals[0]),
+                        operator: "defined",
+                        values: [],
+                    });
+                }
+            }
+            continue;
+        }
+    }
+    return result;
+}
+/** Format a raw filter value back to a string suitable for UI inputs */
+function formatValueForRestore(val, attrType) {
+    if (attrType === "datetime" && typeof val === "number" && val > 0) {
+        return formatDatetimeLocal(val);
+    }
+    return String(val ?? "");
+}
+// ─── Decompose / compose filters by field path ──────────────────
+function getFilterFieldPath(filter) {
+    if (!filter || typeof filter !== "object")
+        return null;
+    if ("not" in filter)
+        return getFilterFieldPath(filter.not);
+    if ("and" in filter) {
+        const children = filter.and;
+        return children.length > 0 ? getFilterFieldPath(children[0]) : null;
+    }
+    if ("or" in filter) {
+        const children = filter.or;
+        return children.length > 0 ? getFilterFieldPath(children[0]) : null;
+    }
+    const key = Object.keys(filter)[0];
+    if (!key)
+        return null;
+    const args = filter[key];
+    return Array.isArray(args) ? args[0] : null;
+}
+function decomposeFilter(filter) {
+    const map = new Map();
+    if (!filter)
+        return map;
+    if (typeof filter === "object" && "and" in filter && Array.isArray(filter.and)) {
+        const byPath = new Map();
+        for (const child of filter.and) {
+            const fp = getFilterFieldPath(child);
+            if (fp) {
+                if (!byPath.has(fp))
+                    byPath.set(fp, []);
+                byPath.get(fp).push(child);
+            }
+        }
+        for (const [fp, filters] of byPath) {
+            if (filters.length === 1) {
+                map.set(fp, filters[0]);
+            }
+            else {
+                map.set(fp, { and: filters });
+            }
+        }
+    }
+    else {
+        const fp = getFilterFieldPath(filter);
+        if (fp)
+            map.set(fp, filter);
+    }
+    return map;
+}
+function composeFilter(attrFilters) {
+    const parts = [];
+    for (const filter of attrFilters.values()) {
+        if (filter !== null)
+            parts.push(filter);
+    }
+    if (parts.length === 0)
+        return null;
+    if (parts.length === 1)
+        return parts[0];
+    return { and: parts };
+}
+// ─── Exhaustive check helper ─────────────────────────────────────
+function assertExhaustive(x, message) {
+    throw new Error(message ?? `Unhandled filter case: ${JSON.stringify(x)}`);
+}
+// ─── Public API ──────────────────────────────────────────────────
+export const filterLogic = {
+    getCategory,
+    getOperatorDefs,
+    getDefaultOperator,
+    buildFilterFromCondition,
+    buildFilter,
+    parseFilter,
+    decomposeFilter,
+    composeFilter,
+    coerceValue,
+    fieldPath,
+    stripFieldPath,
+    formatDatetimeLocal,
+    assertExhaustive,
+};

package/dist/types/types.d.ts

@@ -28,6 +28,19 @@ export type Filter = {
 } | {
     in: [string, string[]];
 } | null;
+export type OperatorKey = "equals" | "notEquals" | "greater" | "greaterOrEqual" | "less" | "lessOrEqual" | "between" | "notBetween" | "empty" | "notEmpty" | "stringContains" | "startsWith" | "endsWith" | "arrayContains" | "notArrayContains" | "length" | "is_true" | "is_false" | "defined" | "undefined";
+export type OperatorDef = {
+    key: OperatorKey;
+    labelKey: string;
+    labelFallback: string;
+    valueCount: 0 | 1 | 2;
+};
+export type FilterCondition = {
+    attributeId: string;
+    operator: OperatorKey;
+    values: string[];
+};
+export type AttrCategory = "numeric" | "text" | "date" | "boolean" | "select" | "multi" | "user" | "existence" | "color" | "skip";
 export type AllocationFilter = {
     root?: Filter;
     relationship?: Filter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dizmo/dcs-client-library",
-  "version": "4.2.3",
+  "version": "4.2.4",
   "description": "A library that allows connection and management of dcs",
   "source": "source/index.ts",
   "main": "dist/index.js",