alinea 2.0.0-preview.7 → 2.0.0-preview.8

package/dist/core/db/EntryResolver.js

@@ -1,699 +0,0 @@
-import {
-  any,
-  array,
-  object
-} from "../../chunks/chunk-I4GC3E65.js";
-import "../../chunks/chunk-CQ52GEHY.js";
-
-// src/core/db/EntryResolver.ts
-import { Entry as EntryExprs } from "alinea/core/Entry";
-import { EntryFields } from "alinea/core/EntryFields";
-import { Field } from "alinea/core/Field";
-import {
-  querySource as queryEdge
-} from "alinea/core/Graph";
-import {
-  getExpr,
-  hasExpr,
-  hasField,
-  hasRoot,
-  hasWorkspace
-} from "alinea/core/Internal";
-import { getScope } from "alinea/core/Scope";
-import { hasExact } from "alinea/core/util/Checks";
-import { entries, fromEntries, isRecord } from "alinea/core/util/Objects";
-import { unreachable } from "alinea/core/util/Types";
-import { createRecord } from "../EntryRecord.js";
-import { compareStrings } from "../source/Utils.js";
-import { assert } from "../util/Assert.js";
-import { aliasesFromData, aliasUrl } from "./EntryAliases.js";
-import {
-  combineConditions
-} from "./EntryIndex.js";
-import { LinkResolver } from "./LinkResolver.js";
-var orFilter = object({ or: array(any) }).and(hasExact(["or"]));
-var andFilter = object({ and: array(any) }).and(hasExact(["and"]));
-var EntryResolver = class {
-  constructor(config, index) {
-    this.config = config;
-    this.#scope = getScope(config);
-    this.index = index;
-  }
-  config;
-  index;
-  #scope;
-  #previewGraphs = /* @__PURE__ */ new WeakMap();
-  call(ctx, entry, internal) {
-    switch (internal.method) {
-      case "snippet": {
-        if (!ctx.searchTerms)
-          throw new Error("Snippet method requires search terms to be provided");
-        const start = this.expr(ctx, entry, internal.args[0]);
-        const end = this.expr(ctx, entry, internal.args[1]);
-        const cutOff = this.expr(ctx, entry, internal.args[2]);
-        const limit = this.expr(ctx, entry, internal.args[3]);
-        return snippet(
-          entry.searchableText,
-          ctx.searchTerms,
-          start,
-          end,
-          cutOff,
-          limit
-        );
-      }
-      default:
-        throw new Error(`Unknown method: "${internal.method}"`);
-    }
-  }
-  field(entry, field) {
-    const name = this.#scope.nameOf(field);
-    if (!name) throw new Error(`Expression has no name ${field}`);
-    return entry.data[name];
-  }
-  expr(ctx, entry, expr) {
-    const internal = getExpr(expr);
-    switch (internal.type) {
-      case "field": {
-        const result = this.field(entry, expr);
-        if (result && typeof result === "object") {
-          return structuredClone(result);
-        }
-        return result;
-      }
-      case "entryField":
-        return entryFieldValue(entry, internal.name, internal.path);
-      case "call":
-        return this.call(ctx, entry, internal);
-      case "value":
-        return internal.value;
-      default:
-        unreachable(internal);
-    }
-  }
-  projectTypes(types) {
-    return entries(EntryFields).concat(types.flatMap(entries));
-  }
-  projection(query) {
-    return query.select ?? fromEntries(
-      (query.type ? this.projectTypes(
-        Array.isArray(query.type) ? query.type : [query.type]
-      ) : []).concat(entries(EntryFields)).concat(query.include ? entries(query.include) : [])
-    );
-  }
-  sourceFilter(ctx, entry, query) {
-    switch (query.edge) {
-      case "parent": {
-        return {
-          nodes: entry.parentId ? [ctx.graph.byId(entry.parentId)] : [],
-          language: (lang) => lang.locale === entry.locale
-        };
-      }
-      case "next": {
-        const parent = entry.parentId ? ctx.graph.byId(entry.parentId) : void 0;
-        const [next] = Array.from(
-          ctx.graph.filter({
-            nodes: parent?.children() ?? [],
-            node: (node) => node.index > entry.index,
-            language: (lang) => lang.locale === entry.locale
-          })
-        ).sort((a, b) => compareStrings(a.index, b.index));
-        const nodes = next ? [ctx.graph.byId(next.id)] : [];
-        return { nodes };
-      }
-      case "previous": {
-        const parent = entry.parentId ? ctx.graph.byId(entry.parentId) : void 0;
-        const [previous] = Array.from(
-          ctx.graph.filter({
-            nodes: parent?.children() ?? [],
-            node: (node) => node.index < entry.index,
-            language: (lang) => lang.locale === entry.locale
-          })
-        ).sort((a, b) => compareStrings(b.index, a.index));
-        const nodes = previous ? [ctx.graph.byId(previous.id)] : [];
-        return { nodes };
-      }
-      case "siblings": {
-        const parent = entry.parentId ? ctx.graph.byId(entry.parentId) : void 0;
-        return {
-          nodes: parent?.children() ?? [],
-          node: (node) => query.includeSelf || node.id !== entry.id,
-          language: (lang) => lang.locale === entry.locale
-        };
-      }
-      case "translations": {
-        const self = ctx.graph.byId(entry.id);
-        assert(self);
-        return {
-          nodes: [self],
-          language: (lang) => query.includeSelf || lang.locale !== entry.locale
-        };
-      }
-      case "children": {
-        const depth = query?.depth ?? 1;
-        const self = ctx.graph.byId(entry.id);
-        return {
-          nodes: ctx.graph.candidateNodes({
-            ids: descendantIds(self, depth)
-          }),
-          language: (language) => language.locale === entry.locale
-        };
-      }
-      case "parents": {
-        const depth = query?.depth ?? Number.POSITIVE_INFINITY;
-        const ids = entry.parents.slice(-depth);
-        const nodes = ids.map((id) => ctx.graph.byId(id));
-        return { nodes, language: (lang) => lang.locale === entry.locale };
-      }
-      case "entryMultiple": {
-        const fieldValue = this.field(entry, query.field);
-        const ids = Array.isArray(fieldValue) ? fieldValue.map((item) => item._entry).filter(Boolean) : [];
-        const nodes = ids.map((id) => ctx.graph.byId(id)).filter(Boolean);
-        return { nodes };
-      }
-      case "entrySingle": {
-        const fieldValue = this.field(entry, query.field);
-        const entryId = fieldValue?._entry;
-        const node = ctx.graph.byId(entryId);
-        return { nodes: node ? [node] : [] };
-      }
-      default:
-        return {};
-    }
-  }
-  selectProjection(ctx, entry, value) {
-    if (value && hasExpr(value)) return this.expr(ctx, entry, value);
-    const source = queryEdge(value);
-    if (!source)
-      return fromEntries(
-        entries(value).map(([key, value2]) => {
-          return [key, this.selectProjection(ctx, entry, value2)];
-        })
-      );
-    const related = value;
-    const isEntryLink = related.edge === "entryMultiple" || related.edge === "entrySingle";
-    const relatedQuery = isEntryLink ? { preferredLocale: entry.locale ?? void 0, ...related } : related;
-    return this.query(
-      { ...ctx, locale: isEntryLink ? void 0 : entry.locale },
-      relatedQuery,
-      this.sourceFilter(ctx, entry, related)
-    ).getUnprocessed();
-  }
-  select(ctx, entry, query) {
-    if (!entry) return null;
-    if (query.select && hasExpr(query.select))
-      return this.expr(ctx, entry, query.select);
-    const fields = this.projection(query);
-    return this.selectProjection(ctx, entry, fields);
-  }
-  condition(ctx, query) {
-    const location = Array.isArray(query.location) ? query.location : query.location && this.#scope.locationOf(query.location);
-    const checkStatus = statusChecker(ctx.status);
-    const checkLocation = location && locationChecker(location);
-    const locale = query.locale ?? ctx.locale;
-    let checkLocale = locale !== void 0 && query.edge !== "translations" && localeChecker(
-      typeof locale === "string" ? locale.toLowerCase() : null,
-      false
-    );
-    if (!checkLocale && query.preferredLocale)
-      checkLocale = localeChecker(query.preferredLocale.toLowerCase(), true);
-    const checkType = Boolean(query.type) && typeChecker(
-      Array.isArray(query.type) ? query.type.map((type) => this.#scope.nameOf(type)) : this.#scope.nameOf(query.type)
-    );
-    const source = queryEdge(query);
-    const checkEntry = entryChecker(this.#scope, query);
-    const checkFilter = query.filter && filterChecker(query.filter, (entry, name) => {
-      if (name.startsWith("_")) return entryFieldValue(entry, name.slice(1));
-      return entry.data[name];
-    });
-    const ids = equalityValues(query.id);
-    return {
-      ids,
-      condition(entry) {
-        if (!checkStatus(entry)) return false;
-        if (checkLocation && !checkLocation(entry)) return false;
-        if (checkType && !checkType(entry)) return false;
-        const matchesLocale = checkLocale ? checkLocale(entry) : true;
-        if (source !== "translations" && !matchesLocale) return false;
-        if (checkEntry && !checkEntry(entry)) return false;
-        if (checkFilter && !checkFilter(entry)) return false;
-        return true;
-      }
-    };
-  }
-  isSingleResult(query) {
-    return Boolean(
-      query.first || query.get || query.count || query.edge === "parent" || query.edge === "next" || query.edge === "previous"
-    );
-  }
-  query(ctx, query, preFilter) {
-    const edge = query;
-    const { skip, take, orderBy, groupBy, search, count } = query;
-    const { ids, condition } = this.condition(ctx, edge);
-    const filter = {
-      search: Array.isArray(search) ? search.join(" ") : search,
-      nodes: preFilter?.nodes ? void 0 : this.#candidateNodes(ctx.graph, query, ids),
-      entry: condition
-    };
-    let entries2 = Array.from(
-      ctx.graph.filter(
-        preFilter ? combineConditions(filter, preFilter) : filter
-      )
-    );
-    if (groupBy) {
-      assert(!Array.isArray(groupBy), "groupBy must be a single field");
-      const groups = /* @__PURE__ */ new Map();
-      for (const entry of entries2) {
-        const value = this.expr(ctx, entry, groupBy);
-        if (!groups.has(value)) groups.set(value, entry);
-      }
-      entries2 = Array.from(groups.values());
-    }
-    if (orderBy) {
-      const orders = Array.isArray(orderBy) ? orderBy : [orderBy];
-      entries2.sort((a, b) => {
-        for (const order of orders) {
-          const ascending = order.asc !== void 0;
-          const descending = order.desc !== void 0;
-          assert(
-            ascending !== descending,
-            "orderBy must specify exactly one direction"
-          );
-          const expr = ascending ? order.asc : order.desc;
-          const valueA = this.expr(ctx, a, expr);
-          const valueB = this.expr(ctx, b, expr);
-          const nullishA = valueA === null || valueA === void 0;
-          const nullishB = valueB === null || valueB === void 0;
-          if (nullishA || nullishB) {
-            if (nullishA !== nullishB) return nullishA ? 1 : -1;
-            continue;
-          }
-          const strings = typeof valueA === "string" && typeof valueB === "string";
-          const numbers = typeof valueA === "number" && typeof valueB === "number";
-          const booleans = typeof valueA === "boolean" && typeof valueB === "boolean";
-          if (strings) {
-            const compare = order.caseSensitive ? compareStrings(valueA, valueB) : valueA.localeCompare(valueB, void 0, { numeric: true });
-            if (compare !== 0) return ascending ? compare : -compare;
-          } else if (numbers) {
-            if (valueA !== valueB)
-              return ascending ? valueA - valueB : valueB - valueA;
-          } else if (booleans && valueA !== valueB) {
-            const compare = Number(valueA) - Number(valueB);
-            return ascending ? compare : -compare;
-          }
-        }
-        return 0;
-      });
-    } else if (edge.edge === "parents") {
-      entries2.sort((a, b) => a.level - b.level);
-    }
-    if (skip) entries2.splice(0, skip);
-    if (take) entries2.splice(take);
-    const isSingle = this.isSingleResult(query);
-    const asEdge = query;
-    const getSelected = () => entries2.map((entry) => this.select(ctx, entry, query));
-    const getUnprocessed = () => {
-      if (count) return entries2.length;
-      const results = getSelected();
-      if (isSingle) return results[0];
-      return results;
-    };
-    const getProcessed = async () => {
-      if (count) return entries2.length;
-      const results = getSelected();
-      if (isSingle) {
-        const entry = entries2[0];
-        if (results[0]) {
-          const linkResolver = new LinkResolver(this, ctx, entry.locale);
-          return await this.postRow({ linkResolver }, results[0], asEdge);
-        }
-        return results[0];
-      }
-      if (results.length > 0) {
-        await Promise.all(
-          results.map((result, index) => {
-            if (!result) return;
-            const linkResolver = new LinkResolver(
-              this,
-              ctx,
-              entries2[index].locale
-            );
-            return this.postRow({ linkResolver }, result, asEdge).then(
-              (processed) => {
-                results[index] = processed;
-              }
-            );
-          }).filter(Boolean)
-        );
-      }
-      return results;
-    };
-    return {
-      entries: entries2,
-      getUnprocessed,
-      getProcessed
-    };
-  }
-  #candidateNodes(graph, query, ids) {
-    const location = Array.isArray(query.location) ? query.location : query.location && this.#scope.locationOf(query.location);
-    const indexedLocation = location && location.length >= 1 && location.length <= 3 ? location : void 0;
-    const workspaceQuery = isRecord(query.workspace) && hasWorkspace(query.workspace) ? this.#scope.nameOf(query.workspace) : query.workspace;
-    const rootQuery = isRecord(query.root) && hasRoot(query.root) ? this.#scope.nameOf(query.root) : query.root;
-    const workspaces = intersectValues(
-      equalityValues(workspaceQuery),
-      indexedLocation?.[0] ? [indexedLocation[0]] : void 0
-    );
-    const roots = intersectValues(
-      equalityValues(rootQuery),
-      indexedLocation?.[1] ? [indexedLocation[1]] : void 0
-    );
-    const types = query.type ? (Array.isArray(query.type) ? query.type : [query.type]).map(
-      (type) => this.#scope.nameOf(type)
-    ) : void 0;
-    return graph.candidateNodes({
-      ids,
-      parentIds: equalityValues(query.parentId),
-      urls: equalityValues(query.url),
-      workspaces,
-      roots,
-      types
-    });
-  }
-  async postField(ctx, interim, field) {
-    return Field.queryValue(field, interim, ctx.linkResolver);
-  }
-  async postExpr(ctx, interim, expr) {
-    if (hasField(expr)) return this.postField(ctx, interim, expr);
-    return interim;
-  }
-  async postRow(ctx, interim, query) {
-    if (!interim) return interim;
-    const selected = this.projection(query);
-    if (hasExpr(selected)) return this.postExpr(ctx, interim, selected);
-    if (queryEdge(selected))
-      return this.post(ctx, interim, selected);
-    await Promise.all(
-      entries(selected).map(async ([key, value]) => {
-        const source = queryEdge(value);
-        if (source)
-          interim[key] = await this.post(
-            ctx,
-            interim[key],
-            value
-          );
-        else
-          interim[key] = await this.postExpr(ctx, interim[key], value);
-      })
-    );
-    return interim;
-  }
-  async post(ctx, interim, input) {
-    if (input.count === true) return interim;
-    const isSingle = this.isSingleResult(input);
-    if (isSingle) return this.postRow(ctx, interim, input);
-    await Promise.all(
-      interim.map(async (row, index) => {
-        interim[index] = await this.postRow(ctx, row, input);
-      })
-    );
-    return interim;
-  }
-  async resolve(query) {
-    const graph = this.#graphFor(query.preview);
-    const ctx = {
-      status: query.status ?? "published",
-      locale: query.locale,
-      graph,
-      searchTerms: Array.isArray(query.search) ? query.search.join(" ") : query.search
-    };
-    return this.query(ctx, query).getProcessed();
-  }
-  #graphFor(preview) {
-    const baseGraph = this.index.graph;
-    if (!preview || !("entry" in preview)) return baseGraph;
-    const cached = this.#previewGraphs.get(preview);
-    if (cached?.baseGraph === baseGraph) return cached.previewGraph;
-    const previewEntry = preview.entry;
-    const previewGraph = baseGraph.withChanges({
-      fromSha: this.index.tree.sha,
-      changes: [
-        {
-          op: "add",
-          path: previewEntry.filePath,
-          sha: previewEntry.fileHash,
-          contents: new TextEncoder().encode(
-            JSON.stringify(
-              createRecord(previewEntry, previewEntry.status),
-              null,
-              2
-            )
-          )
-        }
-      ]
-    });
-    this.#previewGraphs.set(preview, { baseGraph, previewGraph });
-    return previewGraph;
-  }
-};
-function statusChecker(status) {
-  switch (status) {
-    case "published":
-      return (entry) => entry.status === "published";
-    case "draft":
-      return (entry) => entry.status === "draft";
-    case "archived":
-      return (entry) => entry.status === "archived";
-    case "preferDraft":
-      return (entry) => entry.active;
-    case "preferPublished":
-      return (entry) => entry.main;
-    case "all":
-      return (entry) => true;
-  }
-}
-function descendantIds(node, depth) {
-  if (!node || depth <= 0) return [];
-  const result = [];
-  let level = [node];
-  for (let currentDepth = 1; currentDepth <= depth; currentDepth++) {
-    level = level.flatMap((parent) => Array.from(parent.children()));
-    if (level.length === 0) break;
-    for (const child of level) result.push(child.id);
-  }
-  return result;
-}
-function equalityValues(condition) {
-  if (condition === void 0) return void 0;
-  if (typeof condition !== "object" || condition === null)
-    return [condition];
-  const operations = condition;
-  if (operations.is !== void 0) return [operations.is];
-  if (Array.isArray(operations.in)) return operations.in;
-  return void 0;
-}
-function intersectValues(a, b) {
-  if (!a) return b;
-  if (!b) return a;
-  return Array.from(new Set(a).intersection(new Set(b)));
-}
-function entryChecker(scope, query) {
-  const root = isRecord(query.root) && hasRoot(query.root) ? scope.nameOf(query.root) : query.root;
-  const workspace = isRecord(query.workspace) && hasWorkspace(query.workspace) ? scope.nameOf(query.workspace) : query.workspace;
-  const base = filterChecker(
-    {
-      id: query.id,
-      parentId: query.parentId,
-      path: query.path,
-      url: query.url,
-      createdAt: query.createdAt,
-      updatedAt: query.updatedAt,
-      level: query.level,
-      workspace,
-      root
-    },
-    entryFieldValue
-  );
-  if (query.alias === void 0) return base;
-  const hasAlias = aliasChecker(query.alias);
-  return (entry) => base(entry) && hasAlias(entry);
-}
-function entryFieldValue(entry, name, path) {
-  if (name === "aliases") return aliasesFromData(entry.data);
-  if (path) return valueAtPath(entry.data, [...path, name]);
-  const expr = EntryExprs[name];
-  if (expr) {
-    const internal = getExpr(expr);
-    if (internal.type === "entryField" && internal.path)
-      return valueAtPath(entry.data, [...internal.path, internal.name]);
-  }
-  return entry[name];
-}
-function valueAtPath(value, path) {
-  let current = value;
-  for (const segment of path) {
-    if (!isRecord(current)) return void 0;
-    current = current[segment];
-  }
-  return current;
-}
-function aliasChecker(alias) {
-  return filterChecker({ aliases: { includes: { url: alias } } }, (entry) => {
-    const aliases = aliasesFromData(entry.data) ?? [];
-    return aliases.flatMap((row) => {
-      const url = aliasUrl(row);
-      return url === void 0 ? [] : [{ url }];
-    });
-  });
-}
-function typeChecker(type) {
-  if (Array.isArray(type)) {
-    return (entry) => type.includes(entry.type);
-  }
-  return (entry) => entry.type === type;
-}
-function locationChecker(location) {
-  switch (location.length) {
-    case 1:
-      return (entry) => entry.workspace === location[0];
-    case 2:
-      return (entry) => entry.workspace === location[0] && entry.root === location[1];
-    case 3: {
-      return (entry) => {
-        if (entry.workspace !== location[0]) return false;
-        if (entry.root !== location[1]) return false;
-        if (entry.level === 0) return false;
-        if (entry.level === 1)
-          return entry.parentDir.endsWith(`/${location[2]}`);
-        const segment = entry.parentDir.split("/").at(-entry.level);
-        return segment === location[2];
-      };
-    }
-    default:
-      return (entry) => true;
-  }
-}
-function localeChecker(locale, preferred) {
-  return (entry) => {
-    if (preferred && entry.locale === null) return true;
-    if (typeof entry.locale === "string")
-      return entry.locale.toLowerCase() === locale;
-    return entry.locale === locale;
-  };
-}
-function filterChecker(filter, getField = (input, name) => input?.[name]) {
-  const isOrFilter = orFilter.check(filter);
-  if (isOrFilter) {
-    const or = filter.or.filter(Boolean).map((op) => filterChecker(op, getField));
-    return (input) => {
-      for (const fn of or) if (fn(input)) return true;
-      return false;
-    };
-  }
-  const isAndFilter = andFilter.check(filter);
-  if (isAndFilter) {
-    const and = filter.and.filter(Boolean).map((op) => filterChecker(op, getField));
-    return (input) => {
-      for (const fn of and) if (!fn(input)) return false;
-      return true;
-    };
-  }
-  if (typeof filter !== "object" || filter === null) {
-    return (input) => input === filter;
-  }
-  const conditions = createConditions(filter, getField);
-  return (input) => {
-    for (const condition of conditions) if (!condition(input)) return false;
-    return true;
-  };
-}
-function createConditions(ops, getField) {
-  const conditions = Array();
-  for (const [name, op] of entries(ops)) {
-    if (op === void 0) continue;
-    if (typeof op !== "object" || op === null) {
-      conditions.push((input) => getField(input, name) === op);
-      continue;
-    }
-    const inner = op;
-    if (inner.is !== void 0)
-      conditions.push((input) => getField(input, name) === inner.is);
-    if (inner.isNot !== void 0)
-      conditions.push((input) => getField(input, name) !== inner.isNot);
-    const inOp = inner.in;
-    if (Array.isArray(inOp))
-      conditions.push((input) => input && inOp.includes(getField(input, name)));
-    const notInOp = inner.notIn;
-    if (Array.isArray(notInOp))
-      conditions.push(
-        (input) => input && !notInOp.includes(getField(input, name))
-      );
-    if (inner.gt !== void 0)
-      conditions.push((input) => getField(input, name) > inner.gt);
-    if (inner.gte !== void 0)
-      conditions.push((input) => getField(input, name) >= inner.gte);
-    if (inner.lt !== void 0)
-      conditions.push((input) => getField(input, name) < inner.lt);
-    if (inner.lte !== void 0)
-      conditions.push((input) => getField(input, name) <= inner.lte);
-    if (inner.startsWith)
-      conditions.push((input) => {
-        const field = getField(input, name);
-        return typeof field === "string" && field.startsWith(inner.startsWith);
-      });
-    const orOp = inner.or;
-    if (orOp) {
-      const inner2 = Array.isArray(orOp) ? orOp.flatMap((op2) => createConditions(op2, getField)) : createConditions(orOp, getField);
-      conditions.push((input) => {
-        for (const condition of inner2) if (condition(input)) return true;
-        return false;
-      });
-    }
-    if (inner.has) {
-      const has = filterChecker(inner.has);
-      conditions.push((input) => has(getField(input, name)));
-    }
-    if (inner.includes) {
-      const includes = filterChecker(inner.includes);
-      conditions.push((input) => {
-        const field = getField(input, name);
-        if (!Array.isArray(field)) return false;
-        for (const item of field) if (includes(item)) return true;
-        return false;
-      });
-    }
-  }
-  return conditions;
-}
-function snippet(body, searchTerms, start, end, cutOff, limit) {
-  if (limit <= 0 || limit > 64)
-    throw new Error(
-      "The 'limit' parameter must be greater than zero and less than or equal to 64."
-    );
-  const terms = searchTerms.toLowerCase().split(/\s+/).filter((term) => term !== "");
-  const words = body.split(/\s+/);
-  const highlightedWords = Array();
-  let firstMatchIndex = -1;
-  for (let i = 0; i < words.length; i++) {
-    const lowerCaseWord = words[i].toLowerCase();
-    const isMatch = terms.some((term) => lowerCaseWord.includes(term));
-    if (isMatch && firstMatchIndex === -1) firstMatchIndex = i;
-    if (isMatch) highlightedWords.push(`${start}${words[i]}${end}`);
-    else highlightedWords.push(words[i]);
-  }
-  if (firstMatchIndex === -1)
-    return words.slice(0, Math.min(limit, words.length)).join(" ");
-  const idealStartIndex = Math.max(0, firstMatchIndex - Math.floor(limit / 2));
-  const snippetResultWords = highlightedWords.slice(
-    idealStartIndex,
-    idealStartIndex + limit
-  );
-  let snippetResult = snippetResultWords.join(" ");
-  if (idealStartIndex > 0) snippetResult = `${cutOff}${snippetResult}`;
-  if (idealStartIndex + limit < highlightedWords.length)
-    snippetResult = `${snippetResult}${cutOff}`;
-  return snippetResult;
-}
-export {
-  EntryResolver,
-  filterChecker,
-  statusChecker
-};

package/dist/core/db/EntryTarget.d.ts

@@ -1,5 +0,0 @@
-import type { RemoteSource } from '../source/Source.js';
-import type { CommitRequest } from './CommitRequest.js';
-export interface EntryTarget extends RemoteSource {
-    commit(request: CommitRequest): Promise<string>;
-}