@ls-stack/utils 3.26.0 → 3.27.0

package/lib/chunk-FXRZ4RQU.js

@@ -1,257 +0,0 @@
-import {
-  isPlainObject
-} from "./chunk-JF2MDHOJ.js";
-
-// src/filterObjectOrArrayKeys.ts
-function filterObjectOrArrayKeys(objOrArray, {
-  filterKeys,
-  rejectKeys,
-  rejectEmptyObjectsInArray = true
-}) {
-  const toArray = (v) => v === void 0 ? [] : Array.isArray(v) ? v : [v];
-  const filterPatternsRaw = toArray(filterKeys);
-  const rejectPatternsRaw = toArray(rejectKeys);
-  const hasFilters = filterPatternsRaw.length > 0;
-  const hasRejects = rejectPatternsRaw.length > 0;
-  const filterPatterns = filterPatternsRaw.map(parsePattern);
-  const rejectPatterns = rejectPatternsRaw.map(parsePattern);
-  function matchPath(path, pattern) {
-    function rec(pi, pti) {
-      if (pti >= pattern.length) return pi === path.length;
-      const pt = pattern[pti];
-      if (pt.type === "WILDCARD_ANY") {
-        if (rec(pi, pti + 1)) return true;
-        if (pi < path.length) return rec(pi + 1, pti);
-        return false;
-      }
-      if (pt.type === "WILDCARD_ONE") {
-        let j = pi;
-        let sawKey = false;
-        while (j < path.length) {
-          if (path[j].type === "KEY") sawKey = true;
-          if (sawKey && rec(j, pti + 1)) return true;
-          j += 1;
-        }
-        return false;
-      }
-      if (pi >= path.length) return false;
-      const ct = path[pi];
-      switch (pt.type) {
-        case "KEY":
-          if (ct.type === "KEY" && ct.name === pt.name)
-            return rec(pi + 1, pti + 1);
-          if (ct.type === "INDEX") return rec(pi + 1, pti);
-          return false;
-        case "MULTI_KEY":
-          if (ct.type === "KEY" && pt.names.includes(ct.name))
-            return rec(pi + 1, pti + 1);
-          if (ct.type === "INDEX") return rec(pi + 1, pti);
-          return false;
-        case "INDEX":
-          if (ct.type === "INDEX" && ct.index === pt.index)
-            return rec(pi + 1, pti + 1);
-          return false;
-        case "INDEX_ANY":
-          if (ct.type === "INDEX") return rec(pi + 1, pti + 1);
-          return false;
-        case "INDEX_RANGE":
-          if (ct.type === "INDEX") {
-            const okLower = ct.index >= pt.start;
-            const okUpper = pt.end === null ? true : ct.index <= pt.end;
-            if (okLower && okUpper) return rec(pi + 1, pti + 1);
-          }
-          return false;
-      }
-    }
-    return rec(0, 0);
-  }
-  const matchesAnyFilter = (path) => filterPatterns.some((p) => matchPath(path, p));
-  const matchesAnyReject = (path) => rejectPatterns.some((p) => matchPath(path, p));
-  const build = (value, path, allowedByFilter, stack2, isRoot, parentIsArray) => {
-    if (Array.isArray(value)) {
-      if (stack2.has(value)) {
-        throw new TypeError("Circular references are not supported");
-      }
-      stack2.add(value);
-      const out = [];
-      const includeAllChildren = allowedByFilter || !hasFilters;
-      for (let index = 0; index < value.length; index += 1) {
-        const childPath = path.concat({ type: "INDEX", index });
-        if (hasRejects && matchesAnyReject(childPath)) continue;
-        const child = value[index];
-        const directInclude = hasFilters ? matchesAnyFilter(childPath) : true;
-        const childAllowed = includeAllChildren || directInclude;
-        if (isPlainObject(child) || Array.isArray(child)) {
-          const builtChild = build(
-            child,
-            childPath,
-            childAllowed,
-            stack2,
-            false,
-            true
-          );
-          if (builtChild !== void 0) {
-            out.push(builtChild);
-          }
-        } else {
-          if (childAllowed) {
-            out.push(child);
-          }
-        }
-      }
-      stack2.delete(value);
-      const filteredOut = rejectEmptyObjectsInArray ? out.filter(
-        (item) => !(isPlainObject(item) && Object.keys(item).length === 0)
-      ) : out;
-      if (filteredOut.length === 0 && !allowedByFilter && !isRoot)
-        return void 0;
-      return filteredOut;
-    }
-    if (isPlainObject(value)) {
-      if (stack2.has(value)) {
-        throw new TypeError("Circular references are not supported");
-      }
-      stack2.add(value);
-      const result = {};
-      const includeAllChildren = allowedByFilter || !hasFilters;
-      for (const key of Object.keys(value)) {
-        const childPath = path.concat({ type: "KEY", name: key });
-        if (hasRejects && matchesAnyReject(childPath)) continue;
-        const val = value[key];
-        const directInclude = hasFilters ? matchesAnyFilter(childPath) : true;
-        const childAllowed = includeAllChildren || directInclude;
-        if (isPlainObject(val) || Array.isArray(val)) {
-          const builtChild = build(
-            val,
-            childPath,
-            childAllowed,
-            stack2,
-            false,
-            false
-          );
-          if (builtChild === void 0) {
-            continue;
-          }
-          if (Array.isArray(builtChild) && builtChild.length === 0 && !childAllowed) {
-            continue;
-          }
-          if (isPlainObject(builtChild) && Object.keys(builtChild).length === 0 && !childAllowed) {
-            continue;
-          }
-          result[key] = builtChild;
-        } else {
-          if (childAllowed) {
-            result[key] = val;
-          }
-        }
-      }
-      stack2.delete(value);
-      if (Object.keys(result).length === 0 && !allowedByFilter && !isRoot) {
-        if (parentIsArray && !rejectEmptyObjectsInArray) {
-          return {};
-        }
-        return void 0;
-      }
-      return result;
-    }
-    return allowedByFilter || !hasFilters ? value : void 0;
-  };
-  const startPath = [];
-  const initialAllowed = !hasFilters;
-  const stack = /* @__PURE__ */ new WeakSet();
-  const built = build(
-    objOrArray,
-    startPath,
-    initialAllowed,
-    stack,
-    true,
-    false
-  );
-  if (built === void 0) return Array.isArray(objOrArray) ? [] : {};
-  return built;
-}
-function parsePattern(pattern) {
-  const tokens = [];
-  let i = 0;
-  const n = pattern.length;
-  const pushKey = (name) => {
-    if (name.length === 0) return;
-    tokens.push({ type: "KEY", name });
-  };
-  while (i < n) {
-    const ch = pattern[i];
-    if (ch === ".") {
-      i += 1;
-      continue;
-    }
-    if (ch === "[") {
-      const end = pattern.indexOf("]", i + 1);
-      const inside = end === -1 ? pattern.slice(i + 1) : pattern.slice(i + 1, end);
-      if (inside === "*") {
-        tokens.push({ type: "INDEX_ANY" });
-      } else if (inside.includes("-")) {
-        const parts = inside.split("-");
-        const startStr = parts[0] ?? "";
-        const endStr = parts[1] ?? "";
-        const start = parseInt(startStr, 10);
-        const endNum = endStr === "*" ? null : parseInt(endStr, 10);
-        tokens.push({
-          type: "INDEX_RANGE",
-          start,
-          end: endNum === null || Number.isFinite(endNum) ? endNum : null
-        });
-      } else if (inside.length > 0) {
-        const idx = parseInt(inside, 10);
-        tokens.push({ type: "INDEX", index: idx });
-      }
-      i = end === -1 ? n : end + 1;
-      continue;
-    }
-    if (ch === "(") {
-      const end = pattern.indexOf(")", i + 1);
-      const inside = end === -1 ? pattern.slice(i + 1) : pattern.slice(i + 1, end);
-      if (inside.includes("|") && inside.trim().length > 0) {
-        const names = inside.split("|").filter((name) => name.length > 0);
-        if (names.length > 0) {
-          tokens.push({ type: "MULTI_KEY", names });
-        }
-      }
-      i = end === -1 ? n : end + 1;
-      continue;
-    }
-    if (ch === "*") {
-      if (pattern[i + 1] === "*") {
-        tokens.push({ type: "WILDCARD_ANY" });
-        i += 2;
-        let j2 = i;
-        while (j2 < n) {
-          const c = pattern[j2];
-          if (c === "." || c === "[") break;
-          j2 += 1;
-        }
-        if (j2 > i) {
-          pushKey(pattern.slice(i, j2));
-          i = j2;
-        }
-        continue;
-      } else {
-        tokens.push({ type: "WILDCARD_ONE" });
-        i += 1;
-        continue;
-      }
-    }
-    let j = i;
-    while (j < n) {
-      const c = pattern[j];
-      if (c === "." || c === "[") break;
-      j += 1;
-    }
-    pushKey(pattern.slice(i, j));
-    i = j;
-  }
-  return tokens;
-}
-
-export {
-  filterObjectOrArrayKeys
-};