alinea 2.0.0-preview.0 → 2.0.0-preview.2

package/dist/core/Graph.d.ts

@@ -5,6 +5,7 @@ import type { Expr } from './Expr.js';
 import type { Condition, Filter } from './Filter.js';
 import type { Infer, StoredRow } from './Infer.js';
 import type { HasField } from './Internal.js';
+import type { OrderBy } from './OrderBy.js';
 import type { Page } from './Page.js';
 import type { PreviewRequest } from './Preview.js';
 import type { Type } from './Type.js';
@@ -52,11 +53,9 @@ interface SelectObject {
 }
 export type Projection = SelectContent | SelectObject;
 export type InferProjection<Selection> = InferSelection<Selection>;
-export interface Order {
-    asc?: Expr<any>;
-    desc?: Expr<any>;
+export type Order = OrderBy & {
     caseSensitive?: boolean;
-}
+};
 type InferSelection<Selection> = Selection extends GraphQuery & Edge ? Expand<AnyQueryResult<Selection>> : Selection extends Expr<infer V> ? V : {
     [K in keyof Selection]: Selection[K] extends Type<infer V> ? Type.Infer<V> : InferSelection<Selection[K]>;
 };

package/dist/core/ListRow.d.ts

@@ -2,6 +2,8 @@ export interface ListRow {
     _id: string;
     _type: string;
     _index: string;
+    _anchor?: string;
+    _label?: string;
 }
 export declare namespace ListRow {
     const id = "_id";

package/dist/core/OrderBy.d.ts

@@ -1,6 +1,10 @@
 import type { Expr } from './Expr.js';
-export type OrderBy = {
+export interface AscendingOrder {
     asc: Expr<any>;
-} | {
+    desc?: never;
+}
+export interface DescendingOrder {
+    asc?: never;
     desc: Expr<any>;
-};
+}
+export type OrderBy = AscendingOrder | DescendingOrder;

package/dist/core/TextDoc.d.ts

@@ -45,6 +45,17 @@ export interface ElementNode {
 export declare namespace ElementNode {
     const content = "content";
 }
+export interface ImageNode extends ElementNode {
+    _type: 'image';
+    _id?: string;
+    _link?: 'image';
+    _entry?: string;
+    src?: string;
+    alt?: string;
+    title?: string;
+    width?: number | string;
+    height?: number | string;
+}
 export interface BlockNode {
     _id: string;
     _type: string;

package/dist/core/Trace.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from './Config.js';
+export interface Tracer {
+    <Result>(name: string, run: () => Promise<Result>): Promise<Result>;
+}
+export interface TraceSpan {
+    <Result>(operation: () => Promise<Result>): Promise<Result>;
+}
+export declare function trace(config: Config, name: string): TraceSpan;

package/dist/core/Trace.js

@@ -0,0 +1,32 @@
+import "../chunks/chunk-CQ52GEHY.js";
+
+// src/core/Trace.ts
+function trace(config, name) {
+  const tracer = config?.tracer;
+  if (!tracer) return runDirect;
+  return async function runSpan(operation) {
+    let result;
+    let called = false;
+    function run() {
+      if (called) return result;
+      called = true;
+      try {
+        result = operation();
+      } catch (error) {
+        result = Promise.reject(error);
+      }
+      return result;
+    }
+    try {
+      await tracer(name, run);
+    } catch {
+    }
+    return run();
+  };
+}
+function runDirect(operation) {
+  return operation();
+}
+export {
+  trace
+};

package/dist/core/Type.d.ts

@@ -1,4 +1,5 @@
 import type { ComponentType } from 'react';
+import type { Config } from './Config.js';
 import type { EntryStatus } from './Entry.js';
 import type { Expr } from './Expr.js';
 import { Field, type EntryAnchorTarget, type FieldAnchorContext, type FieldBeforeSaveContext } from './Field.js';
@@ -11,7 +12,9 @@ import type { View } from './View.js';
 import type { EntryReferenceTarget } from './db/EntryReference.js';
 import type { SummaryProps } from './media/Summary.js';
 import type { Expand } from './util/Types.js';
-export interface EntryUrlMeta {
+export interface EntryUrlInput {
+    config: Config;
+    data: Record<string, unknown>;
     status: EntryStatus;
     path: string;
     parentPaths: Array<string>;
@@ -19,6 +22,9 @@ export interface EntryUrlMeta {
     workspace: string;
     root: string;
 }
+export interface EntryUrlMeta extends EntryUrlInput {
+    defaultUrl: string;
+}
 export type EntryDefaultView = 'edit' | 'overview';
 export type Type<Definition = object> = Definition & HasType;
 type TypeRow<Definition> = Expand<{

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

@@ -1,5 +1,4 @@
 import type { Change, ChangeFile, ChangesBatch } from '../source/Change.js';
-import type { ReadonlyTree } from '../source/Tree.js';
 import type { User } from '../User.js';
 import type { RemoveFileMutation, UploadFileMutation } from './Mutation.js';
 export interface AddContent extends ChangeFile {
@@ -17,7 +16,5 @@ export interface CommitRequest {
     user?: User;
     fromSha: string;
     intoSha: string;
-    checks: Array<[path: string, sha: string]>;
     changes: Array<CommitChange>;
 }
-export declare function checkCommit(tree: ReadonlyTree, request: CommitRequest): void;

package/dist/core/db/CommitRequest.js

@@ -40,16 +40,7 @@ function sourceChanges(request) {
     })
   };
 }
-function checkCommit(tree, request) {
-  if (tree.sha === request.fromSha) return;
-  for (const [path, sha] of request.checks) {
-    const entry = tree.get(path);
-    if (!entry) throw new Error(`Missing entry for ${path}`);
-    if (entry.sha !== sha) throw new Error(`Entry ${path} has changed`);
-  }
-}
 export {
-  checkCommit,
   commitChanges,
   sourceChanges
 };

package/dist/core/db/EntryDB.js

@@ -13,7 +13,7 @@ var EntryDB = class extends LocalDB {
   async mutate(mutations) {
     const from = await this.source.getTree();
     const tx = new EntryTransaction(this.config, this.index, this.source, from);
-    tx.apply(mutations);
+    await tx.apply(mutations);
     const request = await tx.toRequest();
     const contentChanges = sourceChanges(request);
     const sha = this.indexChanges(contentChanges);

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

@@ -19,12 +19,20 @@ export interface EntryCondition {
     language?(language: EntryLanguageNode): boolean;
     entry?(entry: Entry): boolean;
 }
+interface EntryNodeQuery {
+    ids?: ReadonlyArray<string>;
+    parentIds?: ReadonlyArray<string | null>;
+    urls?: ReadonlyArray<string>;
+    workspaces?: ReadonlyArray<string>;
+    roots?: ReadonlyArray<string>;
+    types?: ReadonlyArray<string>;
+}
 export declare function combineConditions(a: EntryCondition, b: EntryCondition): EntryCondition;
 interface EntryVersionData {
     id: string;
     type: string;
     index: string;
-    searchableText: string;
+    searchableText?: string;
     title: string;
     data: Record<string, unknown>;
     seeded: string | null;
@@ -92,6 +100,7 @@ export declare class EntryGraph {
     nodes: Array<EntryNode>;
     constructor(config: Config, versionData: Map<string, EntryVersionData>, seeds: Map<string, Seed>);
     byId(id: string): EntryNode | undefined;
+    candidateNodes(query: EntryNodeQuery): Array<EntryNode> | undefined;
     get config(): Config;
     byDir(dir: string): EntryNode | undefined;
     entryByFilePath(filePath: string): Entry | undefined;
@@ -104,6 +113,7 @@ export declare class EntryIndex extends EventTarget {
     initialSync: ReadonlyTree | undefined;
     graph: EntryGraph;
     constructor(config: Config);
+    clone(): EntryIndex;
     get sha(): string;
     filter(filter: EntryCondition): Iterable<Entry>;
     findFirst<T extends Record<string, unknown>>(filter: (entry: Entry) => boolean): Entry<T> | undefined;
@@ -113,7 +123,7 @@ export declare class EntryIndex extends EventTarget {
     get references(): Promise<EntryReferenceIndex>;
     sync(source: Source): Promise<string>;
     syncWith(source: Source): Promise<string>;
-    indexChanges(batch: ChangesBatch): Promise<string>;
+    indexChanges(batch: ChangesBatch, targetTree?: ReadonlyTree): Promise<string>;
     seed(source: Source): Promise<void>;
     byId(id: string): EntryNode | undefined;
     fix(source: Source): Promise<void>;

package/dist/core/db/EntryIndex.js

@@ -1840,7 +1840,7 @@ import { IndexEvent } from "./IndexEvent.js";
 function combineConditions(a, b) {
   return {
     search: a.search ?? b.search,
-    nodes: a.nodes ?? b.nodes,
+    nodes: combineNodes(a.nodes, b.nodes),
     node(node) {
       return (a.node ? a.node(node) : true) && (b.node ? b.node(node) : true);
     },
@@ -1852,6 +1852,14 @@ function combineConditions(a, b) {
     }
   };
 }
+function combineNodes(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  return matchingNodes(b, new Set(a));
+}
+function* matchingNodes(nodes, included) {
+  for (const node of nodes) if (included.has(node)) yield node;
+}
 var EntryLanguage = class extends Map {
   locale;
   parentDir;
@@ -1940,6 +1948,8 @@ var EntryLanguageNode = class {
     assert(active, `EntryLanguageNode missing active version`);
     this.active = active;
     this.url = entryUrl(node.entryType, {
+      config: node.graph.config,
+      data: main.data,
       status: main.status,
       path: main.path,
       parentPaths: this.parentPaths,
@@ -1979,6 +1989,7 @@ var EntryLanguageNode = class {
   }
   get entries() {
     if (this.#entries) return this.#entries;
+    const entryType = this.node.entryType;
     const entries2 = (this.inheritedStatus ? [this.active] : [...this.language.values()]).map((version) => {
       return {
         ...version,
@@ -1987,7 +1998,13 @@ var EntryLanguageNode = class {
         parents: this.node.parents,
         url: this.url,
         active: version === this.active,
-        main: version === this.main
+        main: version === this.main,
+        get searchableText() {
+          return version.searchableText ??= Type.searchableText(
+            entryType,
+            version.data
+          );
+        }
       };
     });
     this.#entries = entries2;
@@ -2073,7 +2090,16 @@ var EntryGraph = class _EntryGraph {
   #filesById = /* @__PURE__ */ new Map();
   #byId = /* @__PURE__ */ new Map();
   #byDir = /* @__PURE__ */ new Map();
-  #childrenByParentId = /* @__PURE__ */ new Map();
+  #nodesBy = {
+    parentId: /* @__PURE__ */ new Map(),
+    url: /* @__PURE__ */ new Map(),
+    workspace: /* @__PURE__ */ new Map(),
+    root: /* @__PURE__ */ new Map(),
+    type: /* @__PURE__ */ new Map(),
+    workspaceRoot: /* @__PURE__ */ new Map(),
+    workspaceRootType: /* @__PURE__ */ new Map()
+  };
+  #nodeOrder = /* @__PURE__ */ new Map();
   nodes;
   #singleWorkspace;
   #search;
@@ -2097,16 +2123,92 @@ var EntryGraph = class _EntryGraph {
       this.#byDir.set(dir, version.id);
     }
     this.nodes = [...this.#filesById.keys()].map((file) => this.#mkNode(file)).sort((a, b) => compareStrings(a.index, b.index));
-    for (const node of this.nodes) {
-      if (!node.parentId) continue;
-      const children = this.#childrenByParentId.get(node.parentId) ?? [];
-      children.push(node);
-      this.#childrenByParentId.set(node.parentId, children);
+    for (const [order, node] of this.nodes.entries()) {
+      this.#nodeOrder.set(node, order);
+      this.#indexNode(node);
     }
   }
   byId(id) {
     return this.#byId.get(id);
   }
+  candidateNodes(query) {
+    const candidates = [];
+    const { ids, parentIds, urls, workspaces, roots, types } = query;
+    if (ids) {
+      const nodes = ids.flatMap((id) => this.byId(id) ?? []);
+      return this.#ordered(nodes).filter((node) => this.#matches(node, query));
+    }
+    if (parentIds)
+      candidates.push(this.#fromIndex(this.#nodesBy.parentId, parentIds));
+    if (urls) candidates.push(this.#fromIndex(this.#nodesBy.url, urls));
+    if (workspaces && roots && types) {
+      const keys2 = workspaces.flatMap(
+        (workspace) => roots.flatMap(
+          (root) => types.map((type) => indexKey(workspace, root, type))
+        )
+      );
+      candidates.push(this.#fromIndex(this.#nodesBy.workspaceRootType, keys2));
+    } else if (workspaces && roots) {
+      const keys2 = workspaces.flatMap(
+        (workspace) => roots.map((root) => indexKey(workspace, root))
+      );
+      candidates.push(this.#fromIndex(this.#nodesBy.workspaceRoot, keys2));
+    } else {
+      if (workspaces)
+        candidates.push(this.#fromIndex(this.#nodesBy.workspace, workspaces));
+      if (roots) candidates.push(this.#fromIndex(this.#nodesBy.root, roots));
+      if (types) candidates.push(this.#fromIndex(this.#nodesBy.type, types));
+    }
+    if (candidates.length === 0) return void 0;
+    candidates.sort((a, b) => a.length - b.length);
+    const [smallest, ...rest] = candidates;
+    const intersection = rest.reduce(
+      (result, nodes) => result.intersection(new Set(nodes)),
+      new Set(smallest)
+    );
+    return Array.from(intersection);
+  }
+  #matches(node, query) {
+    const { parentIds, urls, workspaces, roots, types } = query;
+    if (parentIds && !parentIds.includes(node.parentId)) return false;
+    if (workspaces && !workspaces.includes(node.workspace)) return false;
+    if (roots && !roots.includes(node.root)) return false;
+    if (types && !types.includes(node.type)) return false;
+    if (urls) {
+      const matchesUrl = Array.from(node.values()).some(
+        (language) => urls.includes(language.url)
+      );
+      if (!matchesUrl) return false;
+    }
+    return true;
+  }
+  #indexNode(node) {
+    addToIndex(this.#nodesBy.parentId, node.parentId, node);
+    addToIndex(this.#nodesBy.workspace, node.workspace, node);
+    addToIndex(this.#nodesBy.root, node.root, node);
+    addToIndex(this.#nodesBy.type, node.type, node);
+    addToIndex(
+      this.#nodesBy.workspaceRoot,
+      indexKey(node.workspace, node.root),
+      node
+    );
+    addToIndex(
+      this.#nodesBy.workspaceRootType,
+      indexKey(node.workspace, node.root, node.type),
+      node
+    );
+    const urls = new Set(Array.from(node.values(), (language) => language.url));
+    for (const url of urls) addToIndex(this.#nodesBy.url, url, node);
+  }
+  #fromIndex(index, keys2) {
+    if (keys2.length === 1) return [...index.get(keys2[0]) ?? []];
+    return this.#ordered(keys2.flatMap((key) => index.get(key) ?? []));
+  }
+  #ordered(nodes) {
+    return Array.from(new Set(nodes)).sort(
+      (a, b) => this.#nodeOrder.get(a) - this.#nodeOrder.get(b)
+    );
+  }
   get config() {
     return this.#config;
   }
@@ -2258,34 +2360,34 @@ var EntryGraph = class _EntryGraph {
       this,
       type,
       parent,
-      () => this.#childrenByParentId.get(id) ?? [],
+      () => this.#nodesBy.parentId.get(id) ?? [],
       collection
     );
     this.#byId.set(id, node);
     return node;
   }
 };
+function addToIndex(index, key, node) {
+  const nodes = index.get(key) ?? [];
+  nodes.push(node);
+  index.set(key, nodes);
+}
+function indexKey(...parts) {
+  return JSON.stringify(parts);
+}
 var VersionParser = class extends Map {
-  #config;
-  constructor(config) {
-    super();
-    this.#config = config;
-  }
   parse(sha, blob) {
     if (super.has(sha)) return super.get(sha);
     const decoder = new TextDecoder();
     const text = decoder.decode(blob);
     const raw = JSON.parse(text);
     const { meta, data } = parseRecord(raw);
-    const entryType = this.#config.schema[meta.type];
-    const searchableText = Type.searchableText(entryType, data);
     const version = {
       id: meta.id,
       type: meta.type,
       index: meta.index,
       data,
       title: data.title,
-      searchableText,
       seeded: meta.seeded ?? null,
       rowHash: sha,
       fileHash: sha
@@ -2296,7 +2398,7 @@ var VersionParser = class extends Map {
 };
 var ParserCache = class extends WeakMap {
   get = (config) => {
-    if (!this.has(config)) this.set(config, new VersionParser(config));
+    if (!this.has(config)) this.set(config, new VersionParser());
     return super.get(config);
   };
 };
@@ -2334,7 +2436,7 @@ function changedParentIds(previous, next) {
   }
   return parents;
 }
-var EntryIndex = class extends EventTarget {
+var EntryIndex = class _EntryIndex extends EventTarget {
   tree = ReadonlyTree.EMPTY;
   initialSync;
   graph;
@@ -2351,6 +2453,13 @@ var EntryIndex = class extends EventTarget {
     this.graph = new EntryGraph(config, /* @__PURE__ */ new Map(), this.#seeds);
     this.#singleWorkspace = Config.multipleWorkspaces(config) ? void 0 : keys(config.workspaces)[0];
   }
+  clone() {
+    const clone = new _EntryIndex(this.#config);
+    clone.tree = this.tree;
+    clone.initialSync = this.initialSync;
+    clone.graph = this.graph;
+    return clone;
+  }
   get sha() {
     return this.tree.sha;
   }
@@ -2396,9 +2505,9 @@ var EntryIndex = class extends EventTarget {
     if (!this.initialSync) this.initialSync = tree;
     const batch = await bundleContents(source, this.tree.diff(tree));
     if (batch.changes.length === 0) return tree.sha;
-    return this.indexChanges(batch);
+    return this.indexChanges(batch, tree);
   }
-  async indexChanges(batch) {
+  async indexChanges(batch, targetTree) {
     const { fromSha, changes } = batch;
     if (fromSha !== this.tree.sha)
       throw new ShaMismatchError(fromSha, this.tree.sha);
@@ -2442,7 +2551,7 @@ var EntryIndex = class extends EventTarget {
         }
       }
     }
-    const updatedTree = await this.tree.withChanges(batch);
+    const updatedTree = targetTree ?? await this.tree.withChanges(batch);
     const sha = updatedTree.sha;
     this.tree = updatedTree;
     const affectedParentIds = changedParentIds(previousRelations, nextRelations);