@platforma-sdk/model 1.54.7 → 1.54.8

package/dist/filters/converters/filterEmpty.d.ts

@@ -1,4 +0,0 @@
-import { FilterSpec, FilterSpecLeaf } from "@milaboratories/pl-model-common";
-export declare function filterPredicate(item: FilterSpec<FilterSpecLeaf<unknown>, unknown, unknown>): boolean;
-export declare function filterEmptyPieces<T extends FilterSpec<FilterSpecLeaf<unknown>, unknown, unknown>>(item: T): null | T;
-//# sourceMappingURL=filterEmpty.d.ts.map

package/dist/filters/converters/filterEmpty.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"filterEmpty.d.ts","sourceRoot":"","sources":["../../../src/filters/converters/filterEmpty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAE7E,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,GAC1D,OAAO,CAoBT;AAED,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,UAAU,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAC/F,IAAI,EAAE,CAAC,GACN,IAAI,GAAG,CAAC,CA4BV"}

package/dist/filters/converters/filterEmpty.js

@@ -1,46 +0,0 @@
-function filterPredicate(item) {
-    // No need to convert empty steps
-    if (item.type == null) {
-        return false;
-    }
-    if (item.type === "or") {
-        return item.filters.length > 0;
-    }
-    if (item.type === "and") {
-        return item.filters.length > 0;
-    }
-    if (item.type === "not") {
-        return filterPredicate(item.filter);
-    }
-    // Filter out any item that has undefined values in required fields
-    return !Object.values(item).some((v) => v === undefined);
-}
-function filterEmptyPieces(item) {
-    if (item.type === "or" || item.type === "and") {
-        const filtered = item.filters
-            .map(filterEmptyPieces)
-            .filter((f) => f !== null && filterPredicate(f));
-        return filtered.length === 0
-            ? null
-            : {
-                ...item,
-                filters: filtered,
-            };
-    }
-    if (item.type === "not") {
-        const inner = filterEmptyPieces(item.filter);
-        return inner === null || !filterPredicate(inner)
-            ? null
-            : {
-                ...item,
-                filter: inner,
-            };
-    }
-    if (!filterPredicate(item)) {
-        return null;
-    }
-    return item;
-}
-
-export { filterEmptyPieces, filterPredicate };
-//# sourceMappingURL=filterEmpty.js.map

package/dist/filters/converters/filterEmpty.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"filterEmpty.js","sources":["../../../src/filters/converters/filterEmpty.ts"],"sourcesContent":["import { FilterSpec, FilterSpecLeaf } from \"@milaboratories/pl-model-common\";\n\nexport function filterPredicate(\n  item: FilterSpec<FilterSpecLeaf<unknown>, unknown, unknown>,\n): boolean {\n  // No need to convert empty steps\n  if (item.type == null) {\n    return false;\n  }\n\n  if (item.type === \"or\") {\n    return item.filters.length > 0;\n  }\n\n  if (item.type === \"and\") {\n    return item.filters.length > 0;\n  }\n\n  if (item.type === \"not\") {\n    return filterPredicate(item.filter);\n  }\n\n  // Filter out any item that has undefined values in required fields\n  return !Object.values(item).some((v) => v === undefined);\n}\n\nexport function filterEmptyPieces<T extends FilterSpec<FilterSpecLeaf<unknown>, unknown, unknown>>(\n  item: T,\n): null | T {\n  if (item.type === \"or\" || item.type === \"and\") {\n    const filtered = item.filters\n      .map(filterEmptyPieces)\n      .filter((f): f is T => f !== null && filterPredicate(f));\n\n    return filtered.length === 0\n      ? null\n      : {\n          ...item,\n          filters: filtered,\n        };\n  }\n  if (item.type === \"not\") {\n    const inner = filterEmptyPieces(item.filter);\n    return inner === null || !filterPredicate(inner)\n      ? null\n      : {\n          ...item,\n          filter: inner,\n        };\n  }\n\n  if (!filterPredicate(item)) {\n    return null;\n  }\n\n  return item;\n}\n"],"names":[],"mappings":"AAEM,SAAU,eAAe,CAC7B,IAA2D,EAAA;;AAG3D,IAAA,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,EAAE;AACrB,QAAA,OAAO,KAAK;IACd;AAEA,IAAA,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE;AACtB,QAAA,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC;IAChC;AAEA,IAAA,IAAI,IAAI,CAAC,IAAI,KAAK,KAAK,EAAE;AACvB,QAAA,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC;IAChC;AAEA,IAAA,IAAI,IAAI,CAAC,IAAI,KAAK,KAAK,EAAE;AACvB,QAAA,OAAO,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC;IACrC;;AAGA,IAAA,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,SAAS,CAAC;AAC1D;AAEM,SAAU,iBAAiB,CAC/B,IAAO,EAAA;AAEP,IAAA,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,KAAK,EAAE;AAC7C,QAAA,MAAM,QAAQ,GAAG,IAAI,CAAC;aACnB,GAAG,CAAC,iBAAiB;AACrB,aAAA,MAAM,CAAC,CAAC,CAAC,KAAa,CAAC,KAAK,IAAI,IAAI,eAAe,CAAC,CAAC,CAAC,CAAC;AAE1D,QAAA,OAAO,QAAQ,CAAC,MAAM,KAAK;AACzB,cAAE;AACF,cAAE;AACE,gBAAA,GAAG,IAAI;AACP,gBAAA,OAAO,EAAE,QAAQ;aAClB;IACP;AACA,IAAA,IAAI,IAAI,CAAC,IAAI,KAAK,KAAK,EAAE;QACvB,MAAM,KAAK,GAAG,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC;QAC5C,OAAO,KAAK,KAAK,IAAI,IAAI,CAAC,eAAe,CAAC,KAAK;AAC7C,cAAE;AACF,cAAE;AACE,gBAAA,GAAG,IAAI;AACP,gBAAA,MAAM,EAAE,KAAK;aACd;IACP;AAEA,IAAA,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE;AAC1B,QAAA,OAAO,IAAI;IACb;AAEA,IAAA,OAAO,IAAI;AACb;;;;"}

package/src/filters/converters/filterEmpty.test.ts

@@ -1,125 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { FilterSpec, FilterSpecLeaf } from "@milaboratories/pl-model-common";
-import { filterEmptyPieces, filterPredicate } from "./filterEmpty";
-
-type F = FilterSpec<FilterSpecLeaf<string>>;
-
-const leaf: F = { type: "equal", column: "c1", x: 1 };
-const emptyLeaf: F = { type: undefined };
-const incompleteLeaf: F = { type: "equal", column: "c1", x: undefined as unknown as number };
-
-describe("filterPredicate", () => {
-  it("returns false for undefined type", () => {
-    expect(filterPredicate(emptyLeaf)).toBe(false);
-  });
-
-  it("returns true for a valid leaf", () => {
-    expect(filterPredicate(leaf)).toBe(true);
-  });
-
-  it("returns false for a leaf with undefined values", () => {
-    expect(filterPredicate(incompleteLeaf)).toBe(false);
-  });
-
-  it("returns false for and with empty filters", () => {
-    expect(filterPredicate({ type: "and", filters: [] })).toBe(false);
-  });
-
-  it("returns true for and with filters", () => {
-    expect(filterPredicate({ type: "and", filters: [leaf] })).toBe(true);
-  });
-
-  it("returns false for or with empty filters", () => {
-    expect(filterPredicate({ type: "or", filters: [] })).toBe(false);
-  });
-
-  it("returns false for not wrapping an empty filter", () => {
-    expect(filterPredicate({ type: "not", filter: emptyLeaf })).toBe(false);
-  });
-
-  it("returns true for not wrapping a valid filter", () => {
-    expect(filterPredicate({ type: "not", filter: leaf })).toBe(true);
-  });
-});
-
-describe("filterEmptyPieces", () => {
-  it("returns valid leaf as-is", () => {
-    expect(filterEmptyPieces(leaf)).toEqual(leaf);
-  });
-
-  it("returns null for empty leaf", () => {
-    expect(filterEmptyPieces(emptyLeaf)).toBeNull();
-  });
-
-  it("returns null for incomplete leaf", () => {
-    expect(filterEmptyPieces(incompleteLeaf)).toBeNull();
-  });
-
-  // --- and ---
-
-  it("filters out empty children from and", () => {
-    const filter: F = { type: "and", filters: [emptyLeaf, leaf, emptyLeaf] };
-    expect(filterEmptyPieces(filter)).toEqual({ type: "and", filters: [leaf] });
-  });
-
-  it("returns null when all and children are empty", () => {
-    const filter: F = { type: "and", filters: [emptyLeaf, emptyLeaf] };
-    expect(filterEmptyPieces(filter)).toBeNull();
-  });
-
-  it("returns null for and with no children", () => {
-    const filter: F = { type: "and", filters: [] };
-    expect(filterEmptyPieces(filter)).toBeNull();
-  });
-
-  // --- or ---
-
-  it("filters out empty children from or", () => {
-    const leaf2: F = { type: "equal", column: "c2", x: 2 };
-    const filter: F = { type: "or", filters: [leaf, emptyLeaf, leaf2] };
-    expect(filterEmptyPieces(filter)).toEqual({ type: "or", filters: [leaf, leaf2] });
-  });
-
-  it("returns null when all or children are empty", () => {
-    const filter: F = { type: "or", filters: [emptyLeaf] };
-    expect(filterEmptyPieces(filter)).toBeNull();
-  });
-
-  // --- not ---
-
-  it("preserves not with valid inner filter", () => {
-    const filter: F = { type: "not", filter: leaf };
-    expect(filterEmptyPieces(filter)).toEqual({ type: "not", filter: leaf });
-  });
-
-  it("returns null for not wrapping an empty filter", () => {
-    const filter: F = { type: "not", filter: emptyLeaf };
-    expect(filterEmptyPieces(filter)).toBeNull();
-  });
-
-  // --- nested collapse ---
-
-  it("returns null when nested and collapses", () => {
-    const filter: F = {
-      type: "not",
-      filter: { type: "and", filters: [emptyLeaf] },
-    };
-    expect(filterEmptyPieces(filter)).toBeNull();
-  });
-
-  it("returns null when parent and has only a collapsing child", () => {
-    const filter: F = {
-      type: "and",
-      filters: [{ type: "or", filters: [emptyLeaf] }],
-    };
-    expect(filterEmptyPieces(filter)).toBeNull();
-  });
-
-  it("keeps valid siblings when one child collapses", () => {
-    const filter: F = {
-      type: "and",
-      filters: [{ type: "or", filters: [emptyLeaf] }, leaf],
-    };
-    expect(filterEmptyPieces(filter)).toEqual({ type: "and", filters: [leaf] });
-  });
-});

package/src/filters/converters/filterEmpty.ts

@@ -1,57 +0,0 @@
-import { FilterSpec, FilterSpecLeaf } from "@milaboratories/pl-model-common";
-
-export function filterPredicate(
-  item: FilterSpec<FilterSpecLeaf<unknown>, unknown, unknown>,
-): boolean {
-  // No need to convert empty steps
-  if (item.type == null) {
-    return false;
-  }
-
-  if (item.type === "or") {
-    return item.filters.length > 0;
-  }
-
-  if (item.type === "and") {
-    return item.filters.length > 0;
-  }
-
-  if (item.type === "not") {
-    return filterPredicate(item.filter);
-  }
-
-  // Filter out any item that has undefined values in required fields
-  return !Object.values(item).some((v) => v === undefined);
-}
-
-export function filterEmptyPieces<T extends FilterSpec<FilterSpecLeaf<unknown>, unknown, unknown>>(
-  item: T,
-): null | T {
-  if (item.type === "or" || item.type === "and") {
-    const filtered = item.filters
-      .map(filterEmptyPieces)
-      .filter((f): f is T => f !== null && filterPredicate(f));
-
-    return filtered.length === 0
-      ? null
-      : {
-          ...item,
-          filters: filtered,
-        };
-  }
-  if (item.type === "not") {
-    const inner = filterEmptyPieces(item.filter);
-    return inner === null || !filterPredicate(inner)
-      ? null
-      : {
-          ...item,
-          filter: inner,
-        };
-  }
-
-  if (!filterPredicate(item)) {
-    return null;
-  }
-
-  return item;
-}