vlite3 0.1.10 → 0.2.2

package/utils/search.util.js

@@ -0,0 +1,363 @@
+const v = /* @__PURE__ */ new Map();
+function C(e) {
+  e ? v.delete(e) : v.clear();
+}
+function w(e, n) {
+  if (!n.includes(".")) return e?.[n];
+  const i = n.split(".");
+  let t = e;
+  for (const s of i) {
+    if (t == null || typeof t != "object") return;
+    t = t[s];
+  }
+  return t;
+}
+function x(e, n = "") {
+  const i = [];
+  if (!e || typeof e != "object" || Array.isArray(e)) return i;
+  for (const t of Object.keys(e)) {
+    const s = n ? `${n}.${t}` : t, o = e[t];
+    if (o != null && typeof o == "object" && !Array.isArray(o) && !(o instanceof Date) && !(o instanceof RegExp)) {
+      const c = x(o, s);
+      c.length > 0 ? i.push(...c) : i.push(s), i.push(s);
+    } else
+      i.push(s);
+  }
+  return i;
+}
+function j(e, n = "") {
+  const i = {};
+  for (const t of Object.keys(e)) {
+    const s = n ? `${n}.${t}` : t, o = e[t];
+    o != null && typeof o == "object" && !Array.isArray(o) && !(o instanceof RegExp) && !p(o) ? Object.assign(i, j(o, s)) : i[s] = o;
+  }
+  return i;
+}
+function N(e, n) {
+  return e.dataRef ? e.dataRef === n : e.dataLength === n.length;
+}
+function P(e, n, i) {
+  let t = !1;
+  if (n == null) return { isNum: t };
+  const s = Array.isArray(n) ? JSON.stringify(n) : String(n), o = e.hash.get(s);
+  if (o ? o.add(i) : e.hash.set(s, /* @__PURE__ */ new Set([i])), typeof n == "string") {
+    const c = n.toLowerCase(), r = e.inverted.get(c);
+    r ? r.add(i) : e.inverted.set(c, /* @__PURE__ */ new Set([i]));
+  } else if (Array.isArray(n)) {
+    for (const c of n)
+      if (typeof c == "string") {
+        const r = c.toLowerCase(), h = e.inverted.get(r);
+        h ? h.add(i) : e.inverted.set(r, /* @__PURE__ */ new Set([i]));
+      }
+  }
+  return typeof n == "number" && Number.isFinite(n) && (t = !0, e.sorted.push({ value: n, idx: i })), { isNum: t };
+}
+function O(e, n) {
+  if (n) {
+    const s = v.get(n);
+    if (s && N(s, e))
+      return s;
+  }
+  const i = e.length === 0 || typeof e[0] != "object" || e[0] === null, t = {
+    fields: /* @__PURE__ */ new Map(),
+    dataRef: null,
+    dataLength: e.length,
+    primitiveInverted: null
+  };
+  if (t.dataRef = e, i) {
+    const s = /* @__PURE__ */ new Map();
+    for (let o = 0; o < e.length; o++) {
+      const c = String(e[o]).toLowerCase(), r = s.get(c);
+      r ? r.push(o) : s.set(c, [o]);
+    }
+    t.primitiveInverted = s;
+  } else {
+    const s = /* @__PURE__ */ new Set(), o = Math.min(e.length, 100);
+    for (let c = 0; c < o; c++) {
+      const r = e[c];
+      if (r && typeof r == "object")
+        for (const h of x(r))
+          s.add(h);
+    }
+    for (const c of s) {
+      const r = {
+        hash: /* @__PURE__ */ new Map(),
+        inverted: /* @__PURE__ */ new Map(),
+        sorted: [],
+        isNumeric: !1
+      };
+      let h = !1;
+      for (let f = 0; f < e.length; f++) {
+        const l = e[f];
+        if (!l || typeof l != "object") continue;
+        const u = w(l, c), { isNum: d } = P(r, u, f);
+        d && (h = !0);
+      }
+      h && (r.sorted.sort((f, l) => f.value - l.value), r.isNumeric = !0), t.fields.set(c, r);
+    }
+  }
+  return n && v.set(n, t), t;
+}
+function m(e, n) {
+  let i = 0, t = e.length;
+  for (; i < t; ) {
+    const s = i + t >>> 1;
+    e[s].value < n ? i = s + 1 : t = s;
+  }
+  return i;
+}
+function b(e, n) {
+  let i = 0, t = e.length;
+  for (; i < t; ) {
+    const s = i + t >>> 1;
+    e[s].value <= n ? i = s + 1 : t = s;
+  }
+  return i;
+}
+function k(e, n, i) {
+  const t = /* @__PURE__ */ new Set();
+  for (let s = n; s < i; s++)
+    t.add(e[s].idx);
+  return t;
+}
+const E = /* @__PURE__ */ new Set([
+  "$eq",
+  "$ne",
+  "$gt",
+  "$gte",
+  "$lt",
+  "$lte",
+  "$in",
+  "$nin",
+  "$regex",
+  "$exists"
+]);
+function p(e) {
+  return !e || typeof e != "object" || Array.isArray(e) ? !1 : Object.keys(e).some((n) => E.has(n));
+}
+function L(e, n) {
+  if (n.$exists !== void 0) {
+    const i = e != null;
+    if (n.$exists !== i) return !1;
+  }
+  if (n.$eq !== void 0 && e !== n.$eq || n.$ne !== void 0 && e === n.$ne || n.$gt !== void 0 && (typeof e != "number" || e <= n.$gt) || n.$gte !== void 0 && (typeof e != "number" || e < n.$gte) || n.$lt !== void 0 && (typeof e != "number" || e >= n.$lt) || n.$lte !== void 0 && (typeof e != "number" || e > n.$lte))
+    return !1;
+  if (n.$in !== void 0) {
+    const i = String(n.$in).toLowerCase();
+    if (Array.isArray(e)) {
+      if (!e.some((s) => typeof s == "string" && s.toLowerCase().includes(i))) return !1;
+    } else if (typeof e != "string" || !e.toLowerCase().includes(i)) return !1;
+  }
+  if (n.$nin !== void 0) {
+    const i = String(n.$nin).toLowerCase();
+    if (Array.isArray(e)) {
+      if (e.some((s) => typeof s == "string" && s.toLowerCase().includes(i))) return !1;
+    } else if (typeof e == "string" && e.toLowerCase().includes(i)) return !1;
+  }
+  return !(n.$regex !== void 0 && !(n.$regex instanceof RegExp ? n.$regex : new RegExp(n.$regex, "i")).test(String(e)));
+}
+function M(e, n, i) {
+  if (!p(n)) {
+    if (typeof n == "string") {
+      const h = n.toLowerCase(), f = /* @__PURE__ */ new Set();
+      for (const [l, u] of e.inverted)
+        if (l.includes(h))
+          for (const d of u) f.add(d);
+      return f;
+    }
+    const c = Array.isArray(n) ? JSON.stringify(n) : String(n), r = e.hash.get(c);
+    return r ? new Set(r) : /* @__PURE__ */ new Set();
+  }
+  const t = n, s = t.$gt !== void 0 || t.$gte !== void 0 || t.$lt !== void 0 || t.$lte !== void 0;
+  if (s && t.$in === void 0 && t.$nin === void 0 && t.$regex === void 0 && t.$exists === void 0 && t.$ne === void 0 && e.isNumeric && e.sorted.length > 0) {
+    let c = 0, r = e.sorted.length;
+    t.$gte !== void 0 ? c = m(e.sorted, t.$gte) : t.$gt !== void 0 && (c = b(e.sorted, t.$gt)), t.$lte !== void 0 ? r = b(e.sorted, t.$lte) : t.$lt !== void 0 && (r = m(e.sorted, t.$lt));
+    let h = k(e.sorted, c, r);
+    if (t.$eq !== void 0) {
+      const f = /* @__PURE__ */ new Set();
+      for (const l of h)
+        e.sorted.find((u) => u.idx === l && u.value === t.$eq) && f.add(l);
+      h = f;
+    }
+    return h;
+  }
+  if (t.$eq !== void 0 && t.$in === void 0 && t.$nin === void 0 && t.$regex === void 0 && !s) {
+    const c = String(t.$eq), r = e.hash.get(c);
+    return r ? new Set(r) : /* @__PURE__ */ new Set();
+  }
+  if (t.$in !== void 0 && t.$eq === void 0 && t.$ne === void 0 && t.$nin === void 0 && t.$regex === void 0 && !s) {
+    const c = String(t.$in).toLowerCase(), r = /* @__PURE__ */ new Set();
+    for (const [h, f] of e.inverted)
+      if (h.includes(c))
+        for (const l of f) r.add(l);
+    return r;
+  }
+  return null;
+}
+function A(e, n, i) {
+  const t = j(n), s = Object.keys(t);
+  if (s.length === 0) {
+    const c = /* @__PURE__ */ new Set();
+    for (let r = 0; r < e.length; r++) c.add(r);
+    return c;
+  }
+  let o = null;
+  for (const c of s) {
+    const r = t[c], h = i.fields.get(c);
+    let f;
+    if (h) {
+      const l = M(h, r, e.length);
+      if (l !== null)
+        f = l;
+      else {
+        f = /* @__PURE__ */ new Set();
+        const u = o ?? Array.from({ length: e.length }, (d, g) => g);
+        for (const d of u) {
+          const g = e[d];
+          if (!g || typeof g != "object") continue;
+          const a = w(g, c);
+          if (p(r))
+            L(a, r) && f.add(d);
+          else if (typeof r == "string") {
+            const y = r.toLowerCase();
+            (typeof a == "string" && a.toLowerCase().includes(y) || Array.isArray(a) && a.some(($) => typeof $ == "string" && $.toLowerCase().includes(y))) && f.add(d);
+          } else
+            a === r && f.add(d);
+        }
+      }
+    } else {
+      f = /* @__PURE__ */ new Set();
+      const l = o ?? Array.from({ length: e.length }, (u, d) => d);
+      for (const u of l) {
+        const d = e[u];
+        if (!d || typeof d != "object") continue;
+        const g = w(d, c);
+        if (p(r))
+          L(g, r) && f.add(u);
+        else if (typeof r == "string") {
+          const a = r.toLowerCase();
+          (typeof g == "string" && g.toLowerCase().includes(a) || Array.isArray(g) && g.some((y) => typeof y == "string" && y.toLowerCase().includes(a))) && f.add(u);
+        } else
+          g === r && f.add(u);
+      }
+    }
+    if (o === null)
+      o = f;
+    else {
+      const l = /* @__PURE__ */ new Set();
+      for (const u of o)
+        f.has(u) && l.add(u);
+      o = l;
+    }
+    if (o.size === 0) break;
+  }
+  return o ?? /* @__PURE__ */ new Set();
+}
+function R(e, n, i) {
+  const t = n.toLowerCase(), s = /* @__PURE__ */ new Set();
+  if (i.primitiveInverted) {
+    for (const [o, c] of i.primitiveInverted)
+      if (o.includes(t))
+        for (const r of c) s.add(r);
+  } else
+    for (let o = 0; o < e.length; o++)
+      String(e[o]).toLowerCase().includes(t) && s.add(o);
+  return s;
+}
+function q(e, ...n) {
+  if (!Array.isArray(e) || e.length === 0)
+    return { results: [], reset: () => {
+    }, loading: !1 };
+  let i, t = n;
+  if (n.length >= 2 && typeof n[n.length - 1] == "string") {
+    const f = n[n.length - 1];
+    e.length > 0 && (typeof e[0] != "object" || e[0] === null) ? (n.length >= 3 || n.length === 2) && (i = f, t = n.slice(0, -1)) : (i = f, t = n.slice(0, -1));
+  }
+  const s = O(e, i), o = () => {
+    i && C(i);
+  };
+  if (t.length === 0)
+    return { results: [...e], reset: o, loading: !1 };
+  const c = t[0];
+  if (typeof c == "string") {
+    const f = R(e, c, s);
+    return { results: Array.from(f).sort((u, d) => u - d).map((u) => e[u]), reset: o, loading: !1 };
+  }
+  if (Array.isArray(c)) {
+    const f = c, l = /* @__PURE__ */ new Set();
+    for (const g of f) {
+      const a = A(e, g, s);
+      for (const y of a) l.add(y);
+    }
+    let u = l;
+    for (let g = 1; g < t.length; g++) {
+      const a = t[g];
+      if (typeof a != "object" || Array.isArray(a)) continue;
+      const y = A(e, a, s), $ = /* @__PURE__ */ new Set();
+      for (const S of u)
+        y.has(S) && $.add(S);
+      u = $;
+    }
+    return { results: Array.from(u).sort((g, a) => g - a).map((g) => e[g]), reset: o, loading: !1 };
+  }
+  let r = null;
+  for (let f = 0; f < t.length; f++) {
+    const l = t[f];
+    if (typeof l != "object" || l === null || Array.isArray(l)) continue;
+    const u = A(e, l, s);
+    if (r === null)
+      r = u;
+    else {
+      const d = /* @__PURE__ */ new Set();
+      for (const g of r)
+        u.has(g) && d.add(g);
+      r = d;
+    }
+    if (r.size === 0) break;
+  }
+  return { results: r ? Array.from(r).sort((f, l) => f - l).map((f) => e[f]) : [], reset: o, loading: !1 };
+}
+function Q(e, n, i) {
+  const t = {
+    search: () => [],
+    reset: () => {
+    },
+    loading: !0
+  };
+  if (!Array.isArray(e) || e.length === 0)
+    return t.loading = !1, t;
+  const s = O(e, i);
+  t.loading = !1;
+  const o = e.length > 0 && (typeof e[0] != "object" || e[0] === null);
+  return t.reset = () => {
+    i && C(i);
+  }, t.search = (c) => {
+    if (!c || typeof c != "string") return [...e];
+    const r = c.toLowerCase();
+    if (o) {
+      const l = R(e, c, s);
+      return Array.from(l).sort((u, d) => u - d).map((u) => e[u]);
+    }
+    const h = n && n.length > 0 ? n : Array.from(s.fields.keys()), f = /* @__PURE__ */ new Set();
+    for (const l of h) {
+      const u = s.fields.get(l);
+      if (u) {
+        for (const [d, g] of u.inverted)
+          if (d.includes(r))
+            for (const a of g) f.add(a);
+      } else
+        for (let d = 0; d < e.length; d++) {
+          const g = e[d];
+          if (!g || typeof g != "object") continue;
+          const a = w(g, l);
+          a != null && (typeof a == "string" && a.toLowerCase().includes(r) || Array.isArray(a) && a.some((y) => typeof y == "string" && y.toLowerCase().includes(r))) && f.add(d);
+        }
+    }
+    return Array.from(f).sort((l, u) => l - u).map((l) => e[l]);
+  }, t;
+}
+export {
+  Q as lazySearch,
+  C as resetSearchIndex,
+  q as search
+};