@aikotools/datafilter 1.0.0

package/dist/aikotools-datafilter.mjs

@@ -0,0 +1,591 @@
+import { DateTime as E } from "luxon";
+function R(i) {
+  return "matchAny" in i;
+}
+function S(i) {
+  return "match" in i && "expected" in i;
+}
+function k(i, s) {
+  const t = [];
+  if (s.length === 0)
+    return {
+      value: i,
+      found: !0,
+      validPath: []
+    };
+  let e = i;
+  for (let n = 0; n < s.length; n++) {
+    const r = s[n];
+    if (e == null)
+      return {
+        value: void 0,
+        found: !1,
+        error: `Cannot read property '${r}' of ${e}`,
+        validPath: t
+      };
+    if (Array.isArray(e)) {
+      const a = typeof r == "number" ? r : parseInt(String(r), 10);
+      if (isNaN(a))
+        return {
+          value: void 0,
+          found: !1,
+          error: `Array index must be a number, got '${r}'`,
+          validPath: t
+        };
+      if (a < 0 || a >= e.length)
+        return {
+          value: void 0,
+          found: !1,
+          error: `Array index ${a} out of bounds (length: ${e.length})`,
+          validPath: t
+        };
+      t.push(a), e = e[a];
+      continue;
+    }
+    if (typeof e == "object") {
+      const a = String(r);
+      if (!(a in e))
+        return {
+          value: void 0,
+          found: !1,
+          error: `Property '${a}' does not exist`,
+          validPath: t
+        };
+      t.push(a), e = e[a];
+      continue;
+    }
+    return {
+      value: void 0,
+      found: !1,
+      error: `Cannot access property '${r}' of primitive type ${typeof e}`,
+      validPath: t
+    };
+  }
+  return {
+    value: e,
+    found: !0,
+    validPath: t
+  };
+}
+function N(i, s) {
+  const t = k(i, s);
+  return t.found && t.value !== void 0;
+}
+function z(i, s, t) {
+  const e = k(i, s);
+  return e.found && e.value !== void 0 ? e.value : t;
+}
+class M {
+  constructor(s) {
+    this.context = s;
+  }
+  /**
+   * Evaluates a single filter criterion against a data object.
+   *
+   * @param data - The data object to check
+   * @param criterion - The filter criterion to evaluate
+   * @returns FilterCheckResult indicating success or failure
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  evaluateCriterion(s, t) {
+    const e = t.check;
+    return "value" in e ? this.checkValue(s, t.path, e) : "exists" in e ? this.checkExists(s, t.path, e) : "itemExists" in e && "item" in e ? this.checkArrayElement(s, t.path, e) : "type" in e && "size" in e ? this.checkArraySize(s, t.path, e) : "min" in e && "max" in e ? typeof e.min == "number" && typeof e.max == "number" ? this.checkNumericRange(s, t.path, e) : this.checkTimeRange(s, t.path, e) : {
+      status: !1,
+      checkType: "unknown",
+      reason: `Unknown check type: ${JSON.stringify(e)}`
+    };
+  }
+  /**
+   * Checks if a value matches an expected value using deep equality.
+   *
+   * @param data - The data object
+   * @param path - Path to the value
+   * @param check - The value check specification
+   * @returns FilterCheckResult
+   */
+  checkValue(s, t, e) {
+    const n = k(s, t);
+    if (!n.found)
+      return {
+        status: !1,
+        checkType: "checkValue",
+        reason: {
+          message: n.error || "Path not found",
+          path: t
+        }
+      };
+    const r = n.value, a = e.value;
+    return this.deepEqual(r, a) ? {
+      status: !0,
+      checkType: "checkValue"
+    } : {
+      status: !1,
+      checkType: "checkValue",
+      reason: {
+        message: "Value mismatch",
+        path: t,
+        expected: a,
+        actual: r
+      }
+    };
+  }
+  /**
+   * Checks if a path exists in the data object.
+   *
+   * @param data - The data object
+   * @param path - Path to check
+   * @param check - The exists check specification
+   * @returns FilterCheckResult
+   */
+  checkExists(s, t, e) {
+    const n = k(s, t), r = n.found && n.value !== void 0;
+    return e.exists === r ? {
+      status: !0,
+      checkType: "checkExists"
+    } : {
+      status: !1,
+      checkType: "checkExists",
+      reason: {
+        message: e.exists ? `Path should exist but doesn't: ${n.error}` : "Path should not exist but does",
+        path: t
+      }
+    };
+  }
+  /**
+   * Checks if an array contains (or doesn't contain) a specific element.
+   *
+   * @param data - The data object
+   * @param path - Path to the array
+   * @param check - The array element check specification
+   * @returns FilterCheckResult
+   */
+  checkArrayElement(s, t, e) {
+    const n = k(s, t);
+    if (!n.found)
+      return {
+        status: !1,
+        checkType: "checkArrayElement",
+        reason: {
+          message: n.error || "Path not found",
+          path: t
+        }
+      };
+    const r = n.value;
+    if (!Array.isArray(r))
+      return {
+        status: !1,
+        checkType: "checkArrayElement",
+        reason: {
+          message: "Value is not an array",
+          path: t,
+          actualType: typeof r
+        }
+      };
+    const a = r.some((u) => this.deepEqual(u, e.item));
+    return e.itemExists === a ? {
+      status: !0,
+      checkType: "checkArrayElement"
+    } : {
+      status: !1,
+      checkType: "checkArrayElement",
+      reason: {
+        message: e.itemExists ? "Item should exist in array but doesn't" : "Item should not exist in array but does",
+        path: t,
+        item: e.item
+      }
+    };
+  }
+  /**
+   * Checks if an array has the expected size.
+   *
+   * @param data - The data object
+   * @param path - Path to the array
+   * @param check - The array size check specification
+   * @returns FilterCheckResult
+   */
+  checkArraySize(s, t, e) {
+    const n = k(s, t);
+    if (!n.found)
+      return {
+        status: !1,
+        checkType: "checkArraySize",
+        reason: {
+          message: n.error || "Path not found",
+          path: t
+        }
+      };
+    const r = n.value;
+    if (!Array.isArray(r))
+      return {
+        status: !1,
+        checkType: "checkArraySize",
+        reason: {
+          message: "Value is not an array",
+          path: t,
+          actualType: typeof r
+        }
+      };
+    const a = r.length, u = e.size;
+    let c = !1, f = "";
+    switch (e.type) {
+      case "equal":
+        c = a === u, f = `Array length should be ${u} but is ${a}`;
+        break;
+      case "lessThan":
+        c = a < u, f = `Array length should be less than ${u} but is ${a}`;
+        break;
+      case "greaterThan":
+        c = a > u, f = `Array length should be greater than ${u} but is ${a}`;
+        break;
+    }
+    return c ? {
+      status: !0,
+      checkType: "checkArraySize"
+    } : {
+      status: !1,
+      checkType: "checkArraySize",
+      reason: {
+        message: f,
+        path: t,
+        expected: u,
+        actual: a
+      }
+    };
+  }
+  /**
+   * Checks if a timestamp is within the expected time range.
+   *
+   * @param data - The data object
+   * @param path - Path to the timestamp
+   * @param check - The time range check specification
+   * @returns FilterCheckResult
+   */
+  checkTimeRange(s, t, e) {
+    const n = k(s, t);
+    if (!n.found)
+      return {
+        status: !1,
+        checkType: "checkTimeRange",
+        reason: {
+          message: n.error || "Path not found",
+          path: t
+        }
+      };
+    const r = n.value;
+    if (typeof r == "number") {
+      const a = parseInt(e.min), u = parseInt(e.max);
+      return isNaN(a) || isNaN(u) ? {
+        status: !1,
+        checkType: "checkTimeRange",
+        reason: {
+          message: "Min or max is not a valid number",
+          min: e.min,
+          max: e.max
+        }
+      } : r >= a && r <= u ? {
+        status: !0,
+        checkType: "checkTimeRange"
+      } : {
+        status: !1,
+        checkType: "checkTimeRange",
+        reason: {
+          message: `Timestamp ${r} is outside range [${a}, ${u}]`,
+          path: t,
+          actual: r,
+          min: a,
+          max: u
+        }
+      };
+    }
+    if (typeof r == "string") {
+      const a = E.fromISO(r), u = E.fromISO(e.min), c = E.fromISO(e.max);
+      return a.isValid ? !u.isValid || !c.isValid ? {
+        status: !1,
+        checkType: "checkTimeRange",
+        reason: {
+          message: "Invalid min or max time",
+          min: e.min,
+          max: e.max
+        }
+      } : a >= u && a <= c ? {
+        status: !0,
+        checkType: "checkTimeRange"
+      } : {
+        status: !1,
+        checkType: "checkTimeRange",
+        reason: {
+          message: `Timestamp ${r} is outside range [${e.min}, ${e.max}]`,
+          path: t,
+          actual: r,
+          min: e.min,
+          max: e.max
+        }
+      } : {
+        status: !1,
+        checkType: "checkTimeRange",
+        reason: {
+          message: `Invalid timestamp: ${r}`,
+          path: t
+        }
+      };
+    }
+    return {
+      status: !1,
+      checkType: "checkTimeRange",
+      reason: {
+        message: `Timestamp must be a string or number, got ${typeof r}`,
+        path: t
+      }
+    };
+  }
+  /**
+   * Checks if a numeric value is within the expected range.
+   *
+   * @param data - The data object
+   * @param path - Path to the numeric value
+   * @param check - The numeric range check specification
+   * @returns FilterCheckResult
+   */
+  checkNumericRange(s, t, e) {
+    const n = k(s, t);
+    if (!n.found)
+      return {
+        status: !1,
+        checkType: "checkNumericRange",
+        reason: {
+          message: n.error || "Path not found",
+          path: t
+        }
+      };
+    const r = n.value;
+    return typeof r != "number" ? {
+      status: !1,
+      checkType: "checkNumericRange",
+      reason: {
+        message: `Value must be a number, got ${typeof r}`,
+        path: t,
+        actual: r
+      }
+    } : r >= e.min && r <= e.max ? {
+      status: !0,
+      checkType: "checkNumericRange"
+    } : {
+      status: !1,
+      checkType: "checkNumericRange",
+      reason: {
+        message: `Value ${r} is outside range [${e.min}, ${e.max}]`,
+        path: t,
+        actual: r,
+        min: e.min,
+        max: e.max
+      }
+    };
+  }
+  /**
+   * Deep equality comparison.
+   * Compares two values recursively for equality.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  deepEqual(s, t) {
+    if (s === t) return !0;
+    if (s === null || t === null || s === void 0 || t === void 0) return s === t;
+    if (typeof s != typeof t) return !1;
+    if (s instanceof Date && t instanceof Date)
+      return s.getTime() === t.getTime();
+    if (Array.isArray(s) && Array.isArray(t))
+      return s.length !== t.length ? !1 : s.every((e, n) => this.deepEqual(e, t[n]));
+    if (typeof s == "object" && typeof t == "object") {
+      const e = Object.keys(s), n = Object.keys(t);
+      return e.length !== n.length ? !1 : e.every((r) => this.deepEqual(s[r], t[r]));
+    }
+    return s === t;
+  }
+}
+class P {
+  constructor(s) {
+    this.engine = new M(s);
+  }
+  /**
+   * Matches a single file against a rule.
+   *
+   * @param file - The file to match
+   * @param rule - The rule to match against
+   * @returns MatchResult indicating if all criteria matched
+   */
+  matchFile(s, t) {
+    const n = (R(t) ? t.matchAny : t.match).map((a) => this.engine.evaluateCriterion(s.data, a));
+    return {
+      matched: n.every((a) => a.status),
+      checks: n,
+      rule: t
+    };
+  }
+  /**
+   * Applies pre-filter criteria to files, returning only files that match all criteria.
+   *
+   * @param files - Files to filter
+   * @param preFilter - Filter criteria that all files must match
+   * @returns Filtered files that match all preFilter criteria
+   */
+  applyPreFilter(s, t) {
+    return s.filter((e) => t.map((r) => this.engine.evaluateCriterion(e.data, r)).every((r) => r.status));
+  }
+  /**
+   * Main filtering function that processes files according to rules.
+   *
+   * @param files - Files to filter
+   * @param rules - Matching rules (can include arrays for flexible ordering)
+   * @param sortFn - Optional sort function for file ordering
+   * @param preFilter - Optional pre-filter criteria (files not matching are excluded)
+   * @returns FilterResult with mapped, wildcardMatched, and unmapped files
+   */
+  filterFiles(s, t, e, n) {
+    var T, y;
+    const r = n ? this.applyPreFilter(s, n) : s, a = e ? [...r].sort(e) : [...r], u = [], c = [], f = [], p = /* @__PURE__ */ new Set(), x = /* @__PURE__ */ new Map();
+    let o = 0, l = 0;
+    for (; o < a.length; ) {
+      const g = a[o];
+      if (l >= t.length) {
+        p.has(o) || f.push({
+          file: g,
+          attemptedRules: []
+        }), o++;
+        continue;
+      }
+      const d = t[l], F = [];
+      let b = !1;
+      if (Array.isArray(d)) {
+        for (let m = 0; m < d.length; m++) {
+          if ((T = x.get(l)) == null ? void 0 : T.has(m))
+            continue;
+          const v = d[m], $ = this.matchFile(g, v);
+          if (F.push($), $.matched && S(v)) {
+            x.has(l) || x.set(l, /* @__PURE__ */ new Set());
+            const w = x.get(l);
+            w && w.add(m), u.push({
+              expected: v.expected,
+              file: g,
+              matchResult: $,
+              optional: v.optional || !1,
+              info: v.info
+            }), p.add(o), b = !0;
+            break;
+          }
+        }
+        ((y = x.get(l)) == null ? void 0 : y.size) === d.length && l++, o++;
+      } else {
+        const h = d, m = this.matchFile(g, h);
+        F.push(m), m.matched ? S(h) ? (u.push({
+          expected: h.expected,
+          file: g,
+          matchResult: m,
+          optional: h.optional || !1,
+          info: h.info
+        }), p.add(o), l++, o++) : R(h) && (c.push({
+          file: g,
+          matchResult: m,
+          info: h.info
+        }), p.add(o), h.greedy || l++, o++) : h.optional || R(h) ? l++ : (f.push({
+          file: g,
+          attemptedRules: F
+        }), o++);
+      }
+    }
+    const A = {
+      totalFiles: s.length,
+      mappedFiles: u.length,
+      wildcardMatchedFiles: c.length,
+      unmappedFiles: f.length,
+      totalRules: this.countRules(t),
+      mandatoryRules: this.countMandatoryRules(t),
+      optionalRules: this.countOptionalRules(t)
+    };
+    return {
+      mapped: u,
+      wildcardMatched: c,
+      unmapped: f,
+      stats: A
+    };
+  }
+  /**
+   * Counts total number of rules (flattening arrays)
+   */
+  countRules(s) {
+    return s.reduce((t, e) => Array.isArray(e) ? t + e.length : t + 1, 0);
+  }
+  /**
+   * Counts mandatory rules
+   */
+  countMandatoryRules(s) {
+    return s.reduce((t, e) => Array.isArray(e) ? t + e.filter((n) => !n.optional && !R(n)).length : t + (e.optional || R(e) ? 0 : 1), 0);
+  }
+  /**
+   * Counts optional rules
+   */
+  countOptionalRules(s) {
+    return s.reduce((t, e) => Array.isArray(e) ? t + e.filter((n) => n.optional || R(n)).length : t + (e.optional || R(e) ? 1 : 0), 0);
+  }
+  /**
+   * Filtering function for grouped rules with common filter criteria.
+   * Files are first filtered by preFilter (if provided), then matched against
+   * group filters, and finally processed by the group's rules.
+   *
+   * @param files - Files to filter
+   * @param groups - Filter groups with common criteria and rules
+   * @param sortFn - Optional sort function for file ordering
+   * @param preFilter - Optional pre-filter criteria (files not matching are excluded)
+   * @returns FilterResult with mapped, wildcardMatched, and unmapped files
+   */
+  filterFilesWithGroups(s, t, e, n) {
+    const r = n ? this.applyPreFilter(s, n) : s, a = e ? [...r].sort(e) : [...r], u = [], c = [], f = [];
+    for (const o of t) {
+      const l = a.filter((y) => o.groupFilter.map((d) => this.engine.evaluateCriterion(y.data, d)).every((d) => d.status));
+      if (l.length === 0)
+        continue;
+      const A = o.rules.map((y) => (Array.isArray(y), y)), T = this.filterFiles(l, A);
+      u.push(...T.mapped), c.push(...T.wildcardMatched), f.push(...T.unmapped);
+    }
+    const p = t.flatMap((o) => o.rules), x = {
+      totalFiles: s.length,
+      mappedFiles: u.length,
+      wildcardMatchedFiles: c.length,
+      unmappedFiles: f.length,
+      totalRules: this.countRules(p),
+      mandatoryRules: this.countMandatoryRules(p),
+      optionalRules: this.countOptionalRules(p)
+    };
+    return {
+      mapped: u,
+      wildcardMatched: c,
+      unmapped: f,
+      stats: x
+    };
+  }
+}
+function O(i) {
+  const s = new P(i.context);
+  if (i.rules && i.groups)
+    throw new Error('FilterRequest: Provide either "rules" or "groups", not both');
+  if (!i.rules && !i.groups)
+    throw new Error('FilterRequest: Must provide either "rules" or "groups"');
+  if (i.groups)
+    return s.filterFilesWithGroups(
+      i.files,
+      i.groups,
+      i.sortFn,
+      i.preFilter
+    );
+  if (!i.rules)
+    throw new Error("FilterRequest: Rules are required");
+  return s.filterFiles(i.files, i.rules, i.sortFn, i.preFilter);
+}
+export {
+  M as FilterEngine,
+  P as Matcher,
+  O as filterFiles,
+  k as getValueFromPath,
+  z as getValueOr,
+  S as isSingleMatchRule,
+  R as isWildcardRule,
+  N as pathExists
+};

package/dist/src/core/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Core exports for datafilter
+ */
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,SAAS,CAAA"}