alinea 1.7.0 → 2.0.0-preview.1

package/dist/dashboard/atoms/utils.js

@@ -0,0 +1,151 @@
+import {
+  unwrap
+} from "../../chunks/chunk-STAJCW4Z.js";
+import {
+  atom
+} from "../../chunks/chunk-Y7XOMJOC.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/atoms/utils.ts
+import { assertUploadSize } from "alinea/core/media/UploadLimits";
+import { DeepMap } from "alinea/core/util/DeepMap";
+var missing = /* @__PURE__ */ Symbol("required atom missing");
+function requiredAtom(name) {
+  const valueAtom = atom(missing);
+  const result = atom(
+    (get) => {
+      const value = get(valueAtom);
+      if (value === missing)
+        throw new Error(`Required atom "${name}" was not initialized`);
+      return value;
+    },
+    (_get, set, value) => set(valueAtom, value)
+  );
+  result.debugLabel = name;
+  return result;
+}
+function atomWithPending(asyncAtom) {
+  const wrappedAtom = atom(async (get) => {
+    const data = await get(asyncAtom);
+    return [false, data];
+  });
+  return unwrap(wrappedAtom, (previous) => [true, previous?.[1]]);
+}
+function pendingTimerAtom(bufferMs, minimumMs) {
+  const startTimeAtom = atom();
+  const timeoutAtom = atom();
+  const isPendingAtom = atom(false);
+  return atom(
+    (get) => get(isPendingAtom),
+    (get, set, pending) => {
+      const isPending = get(isPendingAtom);
+      const timeout = get(timeoutAtom);
+      if (pending) {
+        if (isPending) {
+          if (timeout !== void 0) {
+            clearTimeout(timeout);
+            set(timeoutAtom, void 0);
+          }
+          return;
+        }
+        if (timeout !== void 0) return;
+        set(startTimeAtom, Date.now());
+        set(
+          timeoutAtom,
+          setTimeout(() => {
+            set(startTimeAtom, Date.now());
+            set(isPendingAtom, true);
+            set(timeoutAtom, void 0);
+          }, bufferMs)
+        );
+        return;
+      }
+      if (!isPending) {
+        if (timeout !== void 0) clearTimeout(timeout);
+        set(startTimeAtom, void 0);
+        set(timeoutAtom, void 0);
+        return;
+      }
+      if (timeout !== void 0) return;
+      const elapsed = Date.now() - (get(startTimeAtom) ?? Date.now());
+      set(
+        timeoutAtom,
+        setTimeout(
+          () => {
+            set(startTimeAtom, void 0);
+            set(isPendingAtom, false);
+            set(timeoutAtom, void 0);
+          },
+          Math.max(0, minimumMs - elapsed)
+        )
+      );
+    }
+  );
+}
+function dispense(fn) {
+  const values = new DeepMap();
+  return function dispenseValue(...keys) {
+    if (!values.has(keys)) values.set(keys, fn(...keys));
+    return values.get(keys);
+  };
+}
+function loader(fn) {
+  let batch = [];
+  return (key) => {
+    return new Promise((resolve) => {
+      if (batch.push({ key, resolve }) === 1) {
+        queueMicrotask(async () => {
+          const current = batch;
+          batch = [];
+          try {
+            const result = await fn(current.map((i) => i.key));
+            for (const [index, item] of current.entries())
+              item.resolve(
+                result[index] ?? [
+                  null,
+                  new Error(`Missing result for ${item.key}`)
+                ]
+              );
+          } catch (e) {
+            const err = e instanceof Error ? e : new Error(String(e));
+            for (const item of current) item.resolve([null, err]);
+          }
+        });
+      }
+    });
+  };
+}
+var dashboardEntryDragType = "application/x-alinea-entry-id";
+var dashboardEntryDragTypes = [
+  dashboardEntryDragType,
+  "text/plain"
+];
+function acceptsDashboardEntryDrag(types) {
+  return dashboardEntryDragTypes.some((type) => types.has(type));
+}
+function dashboardEntryDragItem(id) {
+  const key = String(id);
+  return {
+    "text/plain": key,
+    [dashboardEntryDragType]: key
+  };
+}
+function uploadSizeError(file, maxUploadSize) {
+  try {
+    assertUploadSize(file.name, file.size, maxUploadSize);
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+export {
+  acceptsDashboardEntryDrag,
+  atomWithPending,
+  dashboardEntryDragItem,
+  dashboardEntryDragType,
+  dashboardEntryDragTypes,
+  dispense,
+  loader,
+  pendingTimerAtom,
+  requiredAtom,
+  uploadSizeError
+};

package/dist/dashboard/boot/ActivityEvent.d.ts

@@ -0,0 +1,44 @@
+export type ActivityType = 'mutation' | 'fetch' | 'upload';
+export type ActivityStatus = 'pending' | 'running' | 'succeeded' | 'failed' | 'blocked' | 'discarded' | 'cancelled';
+export interface Activity {
+    id: string;
+    type: ActivityType;
+    status: ActivityStatus;
+    operations: Array<ActivityOperation>;
+    target?: ActivityTarget;
+    startedAt: number;
+    finishedAt?: number;
+    error?: string;
+    upload?: ActivityUpload;
+}
+export interface ActivityTarget {
+    workspace: string;
+    root: string;
+    entry: string;
+    locale?: string | null;
+}
+export interface ActivityUpload {
+    workspace: string;
+    root?: string;
+    parentId?: string;
+}
+export interface ActivityOperation {
+    op: string;
+    target?: string;
+    title?: string;
+    locale?: string | null;
+    status?: string;
+    progress?: ActivityProgress;
+}
+export interface ActivityProgress {
+    loaded: number;
+    total?: number;
+}
+export interface ActivitySource {
+    activities(): Promise<Array<Activity>>;
+}
+export declare class ActivityEvent extends Event {
+    activities: Array<Activity>;
+    static readonly type = "activity";
+    constructor(activities: Array<Activity>);
+}

package/dist/dashboard/boot/ActivityEvent.js

@@ -0,0 +1,14 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/boot/ActivityEvent.ts
+var ActivityEvent = class _ActivityEvent extends Event {
+  constructor(activities) {
+    super(_ActivityEvent.type);
+    this.activities = activities;
+  }
+  activities;
+  static type = "activity";
+};
+export {
+  ActivityEvent
+};

package/dist/dashboard/boot/Boot.js

@@ -1,13 +1,14 @@
 import {
   wrap
-} from "../../chunks/chunk-RSX2DILK.js";
-import "../../chunks/chunk-NZLE2WMY.js";
+} from "../../chunks/chunk-F36YGSHN.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/dashboard/boot/Boot.tsx
 import { IndexEvent } from "alinea/core/db/IndexEvent";
 import { IndexedDBSource } from "alinea/core/source/IndexedDBSource";
 import { createRoot } from "react-dom/client";
 import { App } from "../App.js";
+import { ActivityEvent } from "./ActivityEvent.js";
 import { DashboardWorker } from "./DashboardWorker.js";
 import { loadWorker } from "./LoadWorker.js";
 import { WorkerDB } from "./WorkerDB.js";
@@ -22,7 +23,7 @@ async function boot(gen) {
     try {
       ;
       [events, worker] = createSharedWorker();
-    } catch (error) {
+    } catch {
       console.warn("Shared worker not supported, falling back to local worker.");
       const source = new IndexedDBSource(globalThis.indexedDB, "alinea");
       events = worker = new DashboardWorker(source);
@@ -31,7 +32,8 @@ async function boot(gen) {
     const element = scripts[scripts.length - 1];
     const into = document.createElement("div");
     into.id = "root";
-    element.parentElement.replaceChild(into, element);
+    if (element.parentElement === document.head) document.body.append(into);
+    else element.parentElement.replaceChild(into, element);
     const root = createRoot(into);
     let lastRevision;
     for await (const batch of gen) {
@@ -48,7 +50,7 @@ async function boot(gen) {
       if (isLocal) await worker.load(batch.revision, batch.config, batch.client);
       if (batch.revision !== lastRevision) {
         const db = new WorkerDB(batch.config, worker, batch.client, events);
-        root.render(/* @__PURE__ */ jsx(App, { db, ...batch }));
+        root.render(/* @__PURE__ */ jsx(App, { graph: db, events, ...batch }));
       }
       lastRevision = batch.revision;
     }
@@ -63,6 +65,8 @@ function createSharedWorker() {
   worker.port.addEventListener("message", ({ data }) => {
     if (data.type === IndexEvent.type) {
       events.dispatchEvent(new IndexEvent(data.data));
+    } else if (data.type === ActivityEvent.type) {
+      events.dispatchEvent(new ActivityEvent(data.activities));
     }
   });
   return [events, wrap(worker.port)];

package/dist/dashboard/boot/BootDev.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/dashboard/boot/BootDev.ts
 import { Client } from "alinea/core/Client";
@@ -160,6 +160,7 @@ async function* getConfig() {
   while (true) {
     const next = batch?.revision !== revision ? await createConfig(revision) : batch;
     yield next;
+    batch = next;
     revision = await new Promise((resolve) => {
       source.addEventListener(
         "message",

package/dist/dashboard/boot/BootProd.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/dashboard/boot/BootProd.ts
 import { Client } from "alinea/core/Client";

package/dist/dashboard/boot/DashboardWorker.d.ts

@@ -1,21 +1,21 @@
 import type { Config } from 'alinea/core/Config';
 import type { LocalConnection } from 'alinea/core/Connection';
+import type { EntryReferenceQuery, EntryReferenceResult } from 'alinea/core/db/EntryReference';
 import { LocalDB } from 'alinea/core/db/LocalDB';
 import type { Mutation } from 'alinea/core/db/Mutation';
 import type { Source } from 'alinea/core/source/Source';
-export declare class MutateEvent extends Event {
-    id: string;
-    status: 'success' | 'failure';
-    error?: Error | undefined;
-    static readonly type = "mutate";
-    constructor(id: string, status: 'success' | 'failure', error?: Error | undefined);
-}
+import { type Activity } from './ActivityEvent.js';
 export declare class DashboardWorker extends EventTarget {
     #private;
     constructor(source: Source);
     get db(): LocalDB | Promise<LocalDB>;
     sync(): Promise<string>;
+    sha(): Promise<string>;
     queue(id: string, mutations: Array<Mutation>): Promise<string>;
+    retryActivity(): Promise<void>;
+    discardActivity(): Promise<void>;
+    activities(): Array<Activity>;
     resolve(raw: string): Promise<unknown>;
+    referencesTo(query: EntryReferenceQuery): Promise<EntryReferenceResult>;
     load(revision: string, config: Config, client: LocalConnection): Promise<void>;
 }