alinea 2.0.0-preview.7 → 2.0.0-preview.9

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

@@ -1,21 +0,0 @@
-import type { Config } from 'alinea/core/Config';
-import type { EntryCondition } from 'alinea/core/db/EntryIndex';
-import { type EntryReference, type EntryReferenceQuery, type EntryReferenceResult, type EntryReferenceScan } from 'alinea/core/db/EntryReference';
-import type { Entry } from 'alinea/core/Entry';
-export interface EntryReferenceGraph {
-    config: Config;
-    filter(filter: EntryCondition): Iterable<Entry>;
-}
-export interface EntryReferenceBuildOptions {
-    onProgress?: (scan: EntryReferenceScan) => void;
-}
-export declare class EntryReferenceIndex {
-    #private;
-    static build(graph: EntryReferenceGraph, options?: EntryReferenceBuildOptions): Promise<EntryReferenceIndex>;
-    constructor(config: Config);
-    referencesTo(query: EntryReferenceQuery): EntryReferenceResult;
-    referencesFrom(sourceId: string): Array<EntryReference>;
-    replaceEntry(entry: Entry): Set<string>;
-    removeFile(filePath: string): Set<string>;
-    replaceFile(filePath: string, references: Array<EntryReference>): Set<string>;
-}

package/dist/core/db/EntryReferenceIndex.js

@@ -1,131 +0,0 @@
-import "../../chunks/chunk-CQ52GEHY.js";
-
-// src/core/db/EntryReferenceIndex.ts
-import { Type } from "alinea/core/Type";
-var EntryReferenceIndex = class _EntryReferenceIndex {
-  #config;
-  #refsByFilePath = /* @__PURE__ */ new Map();
-  #refsBySourceId = /* @__PURE__ */ new Map();
-  #refsByTargetId = /* @__PURE__ */ new Map();
-  #indexedFilePaths = /* @__PURE__ */ new Set();
-  static async build(graph, options = {}) {
-    const index = new _EntryReferenceIndex(graph.config);
-    const entries = Array.from(graph.filter({}));
-    let scanned = 0;
-    options.onProgress?.({
-      scanned,
-      total: entries.length,
-      complete: entries.length === 0
-    });
-    for (const entry of entries) {
-      index.replaceEntry(entry);
-      scanned += 1;
-      options.onProgress?.({
-        scanned,
-        total: entries.length,
-        complete: scanned === entries.length
-      });
-      if (scanned % 100 === 0) await Promise.resolve();
-    }
-    return index;
-  }
-  constructor(config) {
-    this.#config = config;
-  }
-  referencesTo(query) {
-    const all = this.#refsByTargetId.get(query.targetId) ?? [];
-    const filtered = all.filter((ref) => matchesReferenceQuery(ref, query));
-    return {
-      references: filtered,
-      total: filtered.length,
-      scan: {
-        scanned: this.#indexedFilePaths.size,
-        total: this.#indexedFilePaths.size,
-        complete: true
-      }
-    };
-  }
-  referencesFrom(sourceId) {
-    return [...this.#refsBySourceId.get(sourceId) ?? []];
-  }
-  replaceEntry(entry) {
-    this.#indexedFilePaths.add(entry.filePath);
-    return this.replaceFile(
-      entry.filePath,
-      entryReferences(this.#config, entry)
-    );
-  }
-  removeFile(filePath) {
-    this.#indexedFilePaths.delete(filePath);
-    return this.replaceFile(filePath, []);
-  }
-  replaceFile(filePath, references) {
-    const affected = /* @__PURE__ */ new Set();
-    const previous = this.#refsByFilePath.get(filePath) ?? [];
-    for (const reference of previous) {
-      affected.add(reference.targetId);
-      removeReference(this.#refsBySourceId, reference.sourceId, reference);
-      removeReference(this.#refsByTargetId, reference.targetId, reference);
-    }
-    if (references.length > 0) this.#refsByFilePath.set(filePath, references);
-    else this.#refsByFilePath.delete(filePath);
-    for (const reference of references) {
-      affected.add(reference.targetId);
-      addReference(this.#refsBySourceId, reference.sourceId, reference);
-      addReference(this.#refsByTargetId, reference.targetId, reference);
-    }
-    return affected;
-  }
-};
-function entryReferences(config, entry) {
-  const type = config.schema[entry.type];
-  if (!type) return [];
-  return Type.references(type, entry.data).map((target) => {
-    return entryReference(entry, target);
-  });
-}
-function entryReference(entry, target) {
-  return {
-    ...target,
-    sourceId: entry.id,
-    sourceFilePath: entry.filePath,
-    sourceType: entry.type,
-    sourceLocale: entry.locale,
-    sourceStatus: entry.status,
-    sourceActive: entry.active,
-    sourceMain: entry.main
-  };
-}
-function addReference(map, key, reference) {
-  const references = map.get(key);
-  if (references) references.push(reference);
-  else map.set(key, [reference]);
-}
-function removeReference(map, key, reference) {
-  const current = map.get(key);
-  if (!current) return;
-  const next = current.filter((item) => item !== reference);
-  if (next.length > 0) map.set(key, next);
-  else map.delete(key);
-}
-function matchesReferenceQuery(reference, query) {
-  if (query.locale !== void 0 && reference.sourceLocale !== query.locale)
-    return false;
-  switch (query.status ?? "published") {
-    case "published":
-      return reference.sourceStatus === "published";
-    case "draft":
-      return reference.sourceStatus === "draft";
-    case "archived":
-      return reference.sourceStatus === "archived";
-    case "preferDraft":
-      return reference.sourceActive;
-    case "preferPublished":
-      return reference.sourceMain;
-    case "all":
-      return true;
-  }
-}
-export {
-  EntryReferenceIndex
-};

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

@@ -1,56 +0,0 @@
-import type { Config } from 'alinea/core/Config';
-import { Entry as EntryExprs, type Entry } from 'alinea/core/Entry';
-import type { Expr } from 'alinea/core/Expr';
-import { Field } from 'alinea/core/Field';
-import type { Filter } from 'alinea/core/Filter';
-import { type AnyQueryResult, type Edge, type EdgeQuery, type GraphQuery, type Projection, type Status } from 'alinea/core/Graph';
-import { type HasExpr } from 'alinea/core/Internal';
-import type { Resolver } from 'alinea/core/Resolver';
-import type { Type } from 'alinea';
-import { type EntryCondition, type EntryFilter, type EntryGraph, type EntryIndex } from './EntryIndex.js';
-import { LinkResolver } from './LinkResolver.js';
-type Interim = any;
-export interface PostContext {
-    linkResolver: LinkResolver;
-}
-export declare class EntryResolver implements Resolver {
-    #private;
-    config: Config;
-    index: EntryIndex;
-    constructor(config: Config, index: EntryIndex);
-    call(ctx: ResolveContext, entry: Entry, internal: {
-        method: string;
-        args: Array<Expr>;
-    }): unknown;
-    field(entry: Entry, field: Expr): unknown;
-    expr(ctx: ResolveContext, entry: Entry, expr: Expr): unknown;
-    projectTypes(types: Array<Type>): Array<[string, Expr]>;
-    projection(query: GraphQuery<Projection>): Projection;
-    sourceFilter(ctx: ResolveContext, entry: Entry, query: EdgeQuery): EntryCondition;
-    selectProjection(ctx: ResolveContext, entry: Entry, value: Projection): unknown;
-    select(ctx: ResolveContext, entry: Entry | null, query: GraphQuery<Projection>): unknown;
-    condition(ctx: ResolveContext, query: EdgeQuery): EntryFilter;
-    isSingleResult(query: GraphQuery & Partial<Edge>): boolean;
-    query(ctx: ResolveContext, query: GraphQuery<Projection>, preFilter?: EntryCondition): {
-        entries: EntryExprs<Record<string, unknown>>[];
-        getUnprocessed: () => unknown;
-        getProcessed: () => Promise<any>;
-    };
-    postField(ctx: PostContext, interim: Interim, field: Field): Promise<unknown>;
-    postExpr(ctx: PostContext, interim: Interim, expr: HasExpr): Promise<unknown>;
-    postRow(ctx: PostContext, interim: Interim, query: GraphQuery<Projection>): Promise<unknown>;
-    post(ctx: PostContext, interim: Interim, input: EdgeQuery<Projection>): Promise<unknown>;
-    resolve<Query extends GraphQuery>(query: Query): Promise<AnyQueryResult<Query>>;
-}
-export interface ResolveContext {
-    status: Status;
-    locale?: string | null;
-    graph: EntryGraph;
-    searchTerms?: string;
-}
-export declare function statusChecker(status: Status): Check;
-interface Check {
-    (input: Entry): boolean;
-}
-export declare function filterChecker(filter: Filter, getField?: (input: any, name: string) => any): Check;
-export {};