chore: remove unused code

Author: iobuhov

packages/shared/filter-commons/src/__tests__/condition-utils.spec.ts

@@ -2,60 +2,9 @@ jest.mock("mendix/filters/builders");
 
 import { AndCondition, FilterCondition } from "mendix/filters";
 import { equals, literal } from "mendix/filters/builders";
-import {
-    compactArray,
-    fromCompactArray,
-    reduceArray,
-    reduceMap,
-    restoreArray,
-    restoreMap,
-    tag
-} from "../condition-utils";
+import { reduceArray, reduceMap, restoreArray, restoreMap, tag } from "../condition-utils";
 
 describe("condition-utils", () => {
-    describe("compactArray", () => {
-        it("returns 'tag' condition for zero array", () => {
-            const result = compactArray([]);
-            expect(result).toMatchObject({
-                name: "!=",
-                type: "function",
-                arg1: { value: "[0,[]]", valueType: "String" }
-            });
-        });
-
-        it("returns 'tag' condition for array of undefined", () => {
-            const result = compactArray([undefined, undefined, undefined]);
-            expect(result).toMatchObject({
-                name: "!=",
-                type: "function",
-                arg1: { value: "[3,[]]", valueType: "String" }
-            });
-        });
-
-        it("returns 'and' condition with 3 args", () => {
-            const result = compactArray([tag("0"), undefined, tag("2")]);
-            expect(result).toMatchObject({ name: "and", type: "function" });
-            expect((result as AndCondition).args).toHaveLength(3);
-        });
-    });
-
-    describe("fromCompactArray", () => {
-        it("unpack condition created with compactArray", () => {
-            const input = [
-                equals(literal("1"), literal("1")),
-                undefined,
-                equals(literal("foo"), literal("bar")),
-                undefined,
-                undefined,
-                equals(literal(new Date("2024-09-17T14:00:00.000Z")), literal(new Date("2024-09-17T14:00:00.000Z")))
-            ];
-            const cond = compactArray(input);
-            expect(cond).toBeDefined();
-            const result = fromCompactArray(cond!);
-            expect(result).toEqual(input);
-        });
-    });
-
     describe("reduceMap", () => {
         it("returns undefined condition and correct metadata for map with undefined values", () => {
             const input = { x: undefined, y: undefined };

packages/shared/filter-commons/src/condition-utils.ts

@@ -73,39 +73,10 @@ export function isTag(cond: FilterCondition): cond is TagCond {
 
 type ArrayMeta = readonly [len: number, indexes: number[]];
 
-function arrayTag(meta: ArrayMeta): string {
-    return JSON.stringify(meta);
-}
-
-function fromArrayTag(tag: string): ArrayMeta | undefined {
-    let len: ArrayMeta[0];
-    let indexes: ArrayMeta[1];
-    try {
-        [len, indexes] = JSON.parse(tag);
-    } catch {
-        return undefined;
-    }
-    if (typeof len !== "number" || !Array.isArray(indexes) || !indexes.every(x => typeof x === "number")) {
-        return undefined;
-    }
-    return [len, indexes];
-}
-
 function shrink<T>(array: Array<T | undefined>): [indexes: number[], items: T[]] {
     return [array.flatMap((x, i) => (x === undefined ? [] : [i])), array.filter((x): x is T => x !== undefined)];
 }
 
-export function compactArray(input: Array<FilterCondition | undefined>): FilterCondition {
-    const [indexes, items] = shrink(input);
-    const metaTag = tag(arrayTag([input.length, indexes] as const));
-
-    if (items.length === 0) {
-        return metaTag;
-    }
-
-    return and(metaTag, ...items);
-}
-
 export function reduceArray(
     input: Array<FilterCondition | undefined>
 ): [cond: FilterCondition | undefined, meta: string] {
@@ -203,29 +174,6 @@ export function restoreMap(
     return result;
 }
 
-export function fromCompactArray(cond: FilterCondition): Array<FilterCondition | undefined> {
-    const tag = isAnd(cond) ? cond.args[0] : cond;
-
-    const arrayMeta = isTag(tag) ? fromArrayTag(tag.arg1.value) : undefined;
-
-    if (!arrayMeta) {
-        return [];
-    }
-
-    const [length, indexes] = arrayMeta;
-    const arr: Array<FilterCondition | undefined> = Array(length).fill(undefined);
-
-    if (!isAnd(cond)) {
-        return arr;
-    }
-
-    cond.args.slice(1).forEach((cond, i) => {
-        arr[indexes[i]] = cond;
-    });
-
-    return arr;
-}
-
 export function inputStateFromCond<Fn, V>(
     cond: FilterCondition,
     fn: (func: FilterFunction | "between" | "empty" | "notEmpty") => Fn,