alinea 1.7.0 → 2.0.0-preview.1

package/dist/dashboard/atoms/activity.js

@@ -0,0 +1,189 @@
+import {
+  atom
+} from "../../chunks/chunk-Y7XOMJOC.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/atoms/activity.ts
+import { startTransition } from "react";
+import {
+  ActivityEvent
+} from "../boot/ActivityEvent.js";
+import { eventsAtom, graphAtom } from "./core.js";
+import { pendingTimerAtom } from "./utils.js";
+var activityHistoryLimit = 100;
+var activityValueAtom = atom([]);
+var uploadActivityAtom = atom([]);
+var activitySpinnerDelay = 100;
+var activitySpinnerMinimumDuration = 1e3;
+var activityPendingAtom = pendingTimerAtom(
+  activitySpinnerDelay,
+  activitySpinnerMinimumDuration
+);
+var activityAtom = Object.assign(
+  atom(
+    (get) => {
+      const activities = [
+        ...get(uploadActivityAtom),
+        ...get(activityValueAtom)
+      ].sort((left, right) => right.startedAt - left.startedAt);
+      return activityState(activities);
+    },
+    (get, set) => {
+      const events = get(eventsAtom);
+      const source = get(graphAtom);
+      let active = true;
+      function update(activities) {
+        startTransition(() => set(activityValueAtom, activities));
+      }
+      function listen(event) {
+        if (event instanceof ActivityEvent) update(event.activities);
+      }
+      events.addEventListener(ActivityEvent.type, listen);
+      void source.activities?.().then(
+        (activities) => {
+          if (active) update(activities);
+        },
+        () => {
+        }
+      );
+      return () => {
+        active = false;
+        events.removeEventListener(ActivityEvent.type, listen);
+      };
+    }
+  ),
+  { onMount: (initialize) => initialize() }
+);
+var retryActivityAtom = atom(null, async (get) => {
+  const graph = get(graphAtom);
+  if (graph.retryActivity) await graph.retryActivity();
+});
+var discardActivityAtom = atom(null, async (get, set) => {
+  const graph = get(graphAtom);
+  if (graph.discardActivity) await graph.discardActivity();
+  set(
+    uploadActivityAtom,
+    (current) => current.map(
+      (activity) => activity.type === "upload" && activity.status === "failed" ? {
+        ...activity,
+        status: "discarded",
+        finishedAt: Date.now(),
+        error: void 0
+      } : activity
+    )
+  );
+});
+var uploadProgressAtom = atom(
+  null,
+  (_get, set, update) => {
+    if (update.type === "start") {
+      const startedAt = Date.now();
+      set(
+        uploadActivityAtom,
+        (current) => trimActivities([
+          ...update.uploads.map(
+            ({ id, file }) => ({
+              id,
+              type: "upload",
+              status: "running",
+              startedAt,
+              upload: update.destination,
+              operations: [
+                {
+                  op: "uploadFile",
+                  title: file.name,
+                  progress: { loaded: 0, total: file.size || void 0 }
+                }
+              ]
+            })
+          ),
+          ...current
+        ])
+      );
+      return;
+    }
+    if (update.type === "progress") {
+      set(
+        uploadActivityAtom,
+        (current) => current.map((entry) => {
+          if (entry.id !== update.id) return entry;
+          return {
+            ...entry,
+            operations: entry.operations.map((operation) => ({
+              ...operation,
+              progress: update.progress
+            }))
+          };
+        })
+      );
+      return;
+    }
+    if (update.type === "fail") {
+      const failedIds = new Set(update.uploads.map((upload) => upload.id));
+      set(uploadActivityAtom, (current) => {
+        const currentById = new Map(current.map((entry) => [entry.id, entry]));
+        return trimActivities([
+          ...update.uploads.map(
+            ({ id, file, error }) => ({
+              id,
+              type: "upload",
+              status: "failed",
+              error,
+              startedAt: currentById.get(id)?.startedAt ?? Date.now(),
+              finishedAt: Date.now(),
+              upload: update.destination,
+              operations: [
+                {
+                  op: "uploadFile",
+                  title: file.name,
+                  progress: { loaded: 0, total: file.size || void 0 }
+                }
+              ]
+            })
+          ),
+          ...current.filter((entry) => !failedIds.has(entry.id))
+        ]);
+      });
+      return;
+    }
+    set(
+      uploadActivityAtom,
+      (current) => current.filter((entry) => !update.ids.includes(entry.id))
+    );
+  }
+);
+function activityState(items) {
+  const latestFetch = items.find((activity) => activity.type === "fetch");
+  const hasFailedFetch = latestFetch?.status === "failed";
+  const hasFailedMutations = items.some(
+    (activity) => activity.type === "mutation" && activity.status === "failed"
+  );
+  const hasFailedUploads = items.some(
+    (activity) => activity.type === "upload" && activity.status === "failed"
+  );
+  return {
+    items,
+    isFetchingUpdates: items.some(
+      (activity) => activity.type === "fetch" && activity.status === "running"
+    ),
+    isMutating: items.some(
+      (activity) => activity.type !== "fetch" && (activity.status === "pending" || activity.status === "running")
+    ),
+    hasFailed: hasFailedMutations || hasFailedUploads || hasFailedFetch,
+    hasFailedMutations,
+    hasBlocked: items.some((activity) => activity.status === "blocked"),
+    canRetry: hasFailedMutations || hasFailedFetch,
+    canDiscard: hasFailedMutations || hasFailedUploads
+  };
+}
+function trimActivities(activities) {
+  return activities.slice(0, activityHistoryLimit);
+}
+export {
+  activityAtom,
+  activityPendingAtom,
+  activityState,
+  discardActivityAtom,
+  retryActivityAtom,
+  uploadProgressAtom
+};

package/dist/dashboard/atoms/auth.d.ts

@@ -0,0 +1,38 @@
+import { User } from 'alinea/core/User';
+export declare const authRequiredAtom: import("jotai").Atom<boolean>;
+export interface DashboardAuthLoading {
+    status: 'loading';
+}
+export interface DashboardAuthMissingHandler {
+    status: 'missingHandler';
+}
+export interface DashboardAuthMissingApiKey {
+    status: 'missingApiKey';
+    setupUrl: string;
+}
+export interface DashboardAuthRedirecting {
+    status: 'redirecting';
+}
+export interface DashboardAuthError {
+    status: 'error';
+    error: Error;
+}
+export interface DashboardAuthAuthenticated {
+    status: 'authenticated';
+    user: User;
+}
+export type DashboardAuthState = DashboardAuthLoading | DashboardAuthMissingHandler | DashboardAuthMissingApiKey | DashboardAuthRedirecting | DashboardAuthError | DashboardAuthAuthenticated;
+interface DashboardAuthCheck {
+    type: 'check';
+}
+interface DashboardAuthSetupCloud {
+    type: 'setupCloud';
+}
+export type DashboardAuthAction = DashboardAuthCheck | DashboardAuthSetupCloud;
+export declare const setUserRolesAtom: import("jotai").WritableAtom<null, [roles: string[]], void> & {
+    init: null;
+};
+export declare const authAtom: import("jotai").WritableAtom<DashboardAuthState, [action?: DashboardAuthAction | undefined], Promise<void>> & {
+    onMount(checkAuth: (action?: DashboardAuthAction) => void): void;
+};
+export {};

package/dist/dashboard/atoms/auth.js

@@ -0,0 +1,106 @@
+import {
+  atom
+} from "../../chunks/chunk-Y7XOMJOC.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/atoms/auth.ts
+import { AuthResultType } from "alinea/cloud/AuthResult";
+import { Client } from "alinea/core/Client";
+import { localUser } from "alinea/core/User";
+import { alineaDevAtom, clientAtom, localAtom } from "./core.js";
+var authRequiredAtom = atom((get) => {
+  const forceAuth = typeof process !== "undefined" && process.env.ALINEA_FORCE_AUTH;
+  if (forceAuth) return true;
+  return !(get(alineaDevAtom) || get(localAtom));
+});
+var authState = atom({ status: "loading" });
+var setUserRolesAtom = atom(null, (get, set, roles) => {
+  const state = get(authAtom);
+  if (state.status === "authenticated")
+    set(authState, { ...state, user: { ...state.user, roles } });
+});
+var authAtom = Object.assign(
+  atom(
+    (get) => {
+      if (!get(authRequiredAtom)) {
+        const userData = typeof process !== "undefined" && process.env.ALINEA_USER;
+        return {
+          status: "authenticated",
+          user: userData ? JSON.parse(userData) : localUser
+        };
+      }
+      return get(authState);
+    },
+    async (get, set, action = { type: "check" }) => {
+      if (action.type === "setupCloud") {
+        const state = get(authState);
+        if (state.status !== "missingApiKey") return;
+        window.location.href = appendFrom(state.setupUrl);
+        return;
+      }
+      if (!get(authRequiredAtom)) return;
+      const client = get(clientAtom);
+      if (!(client instanceof Client)) {
+        set(authState, {
+          status: "error",
+          error: new Error("Cannot authenticate with non http client")
+        });
+        return;
+      }
+      set(authState, { status: "loading" });
+      try {
+        const result = await client.authStatus();
+        switch (result.type) {
+          case AuthResultType.NeedsRefresh:
+            set(authState, {
+              status: "error",
+              error: new Error(
+                "Authentication failure, please refresh the page"
+              )
+            });
+            return;
+          case AuthResultType.Authenticated:
+            set(
+              clientAtom,
+              client.authenticate(
+                (options) => options,
+                () => set(authAtom, { type: "check" })
+              )
+            );
+            set(authState, { status: "authenticated", user: result.user });
+            return;
+          case AuthResultType.UnAuthenticated:
+            set(authState, { status: "redirecting" });
+            window.location.href = appendFrom(result.redirect);
+            return;
+          case AuthResultType.MissingApiKey:
+            set(authState, {
+              status: "missingApiKey",
+              setupUrl: result.setupUrl
+            });
+            return;
+        }
+      } catch {
+        set(authState, { status: "missingHandler" });
+      }
+    }
+  ),
+  {
+    onMount(checkAuth) {
+      checkAuth({ type: "check" });
+    }
+  }
+);
+function appendFrom(url) {
+  const { location } = window;
+  const from = encodeURIComponent(
+    `${location.protocol}//${location.host}${location.pathname}`
+  );
+  const separator = url.includes("?") ? "&" : "?";
+  return `${url}${separator}from=${from}`;
+}
+export {
+  authAtom,
+  authRequiredAtom,
+  setUserRolesAtom
+};

package/dist/dashboard/atoms/config.d.ts

@@ -0,0 +1,27 @@
+import { ComponentType } from 'react';
+export declare const workspacesAtom: import("jotai").Atom<string[]>;
+export declare const workspaceAtom: (workspaceKey: string) => import("jotai").Atom<import("../../core/Workspace.js").WorkspaceInternal>;
+export declare const viewAtoms: (key: string) => import("jotai").Atom<ComponentType | undefined>;
+export declare const typeAtoms: (typeName: string) => import("jotai").Atom<{
+    type: import("../../types.js").Type;
+    customView: ((props: {
+        type: import("../../types.js").Type;
+    }) => import("react").ReactNode) | ComponentType | undefined;
+    fields: import("../../core/Type.js").FieldsDefinition;
+    contains?: Array<string | import("../../types.js").Type>;
+    orderChildrenBy?: import("../../core/OrderBy.js").OrderBy | Array<import("../../core/OrderBy.js").OrderBy>;
+    hidden?: true;
+    icon?: ComponentType;
+    view?: import("../../core/View.js").View<{
+        type: import("../../types.js").Type;
+    }>;
+    defaultView?: import("../../core/Type.js").EntryDefaultView;
+    summaryRow?: import("../../core/View.js").View<import("../../core/media/Summary.js").SummaryProps>;
+    summaryThumb?: import("../../core/View.js").View<import("../../core/media/Summary.js").SummaryProps>;
+    insertOrder?: 'first' | 'last' | 'free';
+    entryUrl?: (meta: import("../../core/Type.js").EntryUrlMeta) => string;
+    preview?: import("../../core/Preview.js").Preview;
+    label: string;
+    allFields: Record<string, import("../../core.js").Field>;
+    sections: Array<import("../../core/Section.js").Section>;
+}>;

package/dist/dashboard/atoms/config.js

@@ -0,0 +1,49 @@
+import {
+  atom
+} from "../../chunks/chunk-Y7XOMJOC.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/atoms/config.ts
+import { getType, getWorkspace } from "alinea/core/Internal";
+import { assert } from "alinea/core/util/Assert";
+import { configAtom, viewsAtom } from "./core.js";
+import { dispense } from "./utils.js";
+import { policyAtom } from "./user.js";
+var workspacesAtom = atom((get) => {
+  const config = get(configAtom);
+  const policy = get(policyAtom);
+  return Object.keys(config.workspaces).filter((workspace) => {
+    return policy.canRead({ workspace });
+  });
+});
+var workspaceAtom = dispense((workspaceKey) => {
+  assert(workspaceKey, "Workspace key cannot be empty");
+  return atom((get) => {
+    const config = get(configAtom);
+    const workspaceConfig = config.workspaces[workspaceKey];
+    assert(workspaceConfig, `Workspace "${workspaceKey}" not found in config`);
+    return getWorkspace(workspaceConfig);
+  });
+});
+var viewAtoms = dispense((key) => {
+  return atom((get) => {
+    const views = get(viewsAtom);
+    return views[key];
+  });
+});
+var typeAtoms = dispense((typeName) => {
+  return atom((get) => {
+    const config = get(configAtom);
+    const type = config.schema[typeName];
+    assert(type, `Type "${typeName}" not found in config`);
+    const typeConfig = getType(type);
+    const customView = typeof typeConfig.view === "string" ? get(viewAtoms(typeConfig.view)) : typeConfig.view;
+    return { ...typeConfig, type, customView };
+  });
+});
+export {
+  typeAtoms,
+  viewAtoms,
+  workspaceAtom,
+  workspacesAtom
+};

package/dist/dashboard/atoms/core.d.ts

@@ -0,0 +1,15 @@
+import { Config } from 'alinea/core/Config';
+import { LocalConnection } from 'alinea/core/Connection';
+import { WriteableGraph } from 'alinea/core/db/WriteableGraph';
+import { ComponentType } from 'react';
+import { AppProps } from '../App.js';
+export declare const graphAtom: import("jotai").WritableAtom<WriteableGraph, [WriteableGraph], void>;
+export declare const eventsAtom: import("jotai").WritableAtom<EventTarget, [EventTarget], void>;
+export declare const configAtom: import("jotai").WritableAtom<Config, [Config], void>;
+export declare const clientAtom: import("jotai").WritableAtom<LocalConnection, [LocalConnection], void>;
+export declare const viewsAtom: import("jotai").PrimitiveAtom<Record<string, ComponentType>> & {
+    init: Record<string, ComponentType>;
+};
+export declare const localAtom: import("jotai").WritableAtom<boolean, [boolean], void>;
+export declare const alineaDevAtom: import("jotai").WritableAtom<boolean, [boolean], void>;
+export declare function useInitAtoms(props: AppProps): void;

package/dist/dashboard/atoms/core.js

@@ -0,0 +1,37 @@
+import {
+  useStore
+} from "../../chunks/chunk-U4VOHNR2.js";
+import {
+  atom
+} from "../../chunks/chunk-Y7XOMJOC.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/atoms/core.ts
+import { requiredAtom } from "./utils.js";
+var graphAtom = requiredAtom("graph");
+var eventsAtom = requiredAtom("events");
+var configAtom = requiredAtom("config");
+var clientAtom = requiredAtom("client");
+var viewsAtom = atom({});
+var localAtom = requiredAtom("local");
+var alineaDevAtom = requiredAtom("alineaDev");
+function useInitAtoms(props) {
+  const store = useStore();
+  store.set(graphAtom, props.graph);
+  store.set(eventsAtom, props.events);
+  store.set(configAtom, props.config);
+  store.set(clientAtom, props.client);
+  store.set(viewsAtom, props.views);
+  store.set(localAtom, Boolean(props.local));
+  store.set(alineaDevAtom, Boolean(props.alineaDev));
+}
+export {
+  alineaDevAtom,
+  clientAtom,
+  configAtom,
+  eventsAtom,
+  graphAtom,
+  localAtom,
+  useInitAtoms,
+  viewsAtom
+};

package/dist/dashboard/atoms/create.d.ts

@@ -0,0 +1,13 @@
+export interface CreateEntryRequest {
+    workspace: string;
+    root: string;
+    locale: string | null;
+    type: string;
+    title: string;
+    parentId?: string;
+    copyFrom?: string;
+    insertOrder?: 'first' | 'last';
+}
+export declare const createEntryAtom: import("jotai").WritableAtom<null, [request: CreateEntryRequest], Promise<import("../../core/EntryFields.js").EntryFields & object>> & {
+    init: null;
+};

package/dist/dashboard/atoms/create.js

@@ -0,0 +1,79 @@
+import {
+  atom
+} from "../../chunks/chunk-Y7XOMJOC.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/atoms/create.ts
+import { Entry } from "alinea/core/Entry";
+import { MediaLibrary } from "alinea/core/media/MediaTypes";
+import { Permission } from "alinea/core/Role";
+import { Type } from "alinea/core/Type";
+import { assert } from "alinea/core/util/Assert";
+import { slugify } from "alinea/core/util/Slugs";
+import { configAtom, graphAtom } from "./core.js";
+import { routeAtom } from "./nav.js";
+import { policyAtom, userAtom } from "./user.js";
+var createEntryAtom = atom(
+  null,
+  async (get, set, request) => {
+    const policy = get(policyAtom);
+    const user = get(userAtom);
+    const config = get(configAtom);
+    const graph = get(graphAtom);
+    const type = config.schema[request.type];
+    assert(type, `Type "${request.type}" not found in config`);
+    const title = request.title.trim();
+    assert(title, "Title is required");
+    const copiedData = request.copyFrom ? await graph.first({
+      select: Entry.data,
+      id: request.copyFrom,
+      locale: request.locale,
+      status: "preferPublished"
+    }) : void 0;
+    const parent = request.parentId ? await graph.first({
+      select: { type: Entry.type, parents: Entry.parents },
+      id: request.parentId,
+      status: "preferDraft"
+    }) : void 0;
+    const parentType = parent ? config.schema[parent.type] : void 0;
+    const parentInsertOrder = parentType && Type.insertOrder(parentType);
+    policy.assert(Permission.Create, {
+      workspace: request.workspace,
+      root: request.root,
+      locale: request.locale,
+      type: request.type,
+      parents: request.parentId ? [request.parentId, ...parent?.parents ?? []] : []
+    });
+    const initialData = Type.withInitialValue(type, {
+      ...Type.initialValue(type),
+      ...copiedData,
+      title,
+      path: slugify(title)
+    });
+    const data = Type.beforeSave(type, initialData, {
+      action: "create",
+      user,
+      now: /* @__PURE__ */ new Date()
+    });
+    const created = await graph.create({
+      type,
+      workspace: request.workspace,
+      root: request.root,
+      parentId: request.parentId,
+      locale: request.locale,
+      status: type === MediaLibrary || !config.enableDrafts ? "published" : "draft",
+      insertOrder: parentInsertOrder && parentInsertOrder !== "free" ? parentInsertOrder : request.insertOrder,
+      set: data
+    });
+    set(routeAtom, {
+      workspace: request.workspace,
+      root: request.root,
+      entry: created._id,
+      locale: request.locale ?? void 0
+    });
+    return created;
+  }
+);
+export {
+  createEntryAtom
+};

package/dist/dashboard/atoms/dashboard.d.ts

@@ -0,0 +1,12 @@
+import type { SetStateAction } from 'react';
+export type DashboardTheme = 'system' | 'light' | 'dark';
+export declare const entrySidebarOpenAtom: import("jotai").PrimitiveAtom<boolean> & {
+    init: boolean;
+};
+export declare const themeAtom: import("jotai").WritableAtom<DashboardTheme, [update: SetStateAction<DashboardTheme>], void> & {
+    onMount(setTheme: (update: SetStateAction<DashboardTheme>) => void): void;
+};
+export declare const canLogoutAtom: import("jotai").Atom<boolean>;
+export declare const logoutAtom: import("jotai").WritableAtom<null, [], Promise<void>> & {
+    init: null;
+};

package/dist/dashboard/atoms/dashboard.js

@@ -0,0 +1,71 @@
+import {
+  atomWithStorage
+} from "../../chunks/chunk-STAJCW4Z.js";
+import {
+  atom
+} from "../../chunks/chunk-Y7XOMJOC.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/atoms/dashboard.ts
+import { authAtom, authRequiredAtom } from "./auth.js";
+import { clientAtom } from "./core.js";
+var dashboardThemeStorageKey = "alinea-dashboard-theme";
+var themeStorageAtom = atomWithStorage(
+  dashboardThemeStorageKey,
+  "system",
+  void 0
+);
+var entrySidebarOpenAtom = atom(
+  typeof window === "undefined" || !window.matchMedia?.("(max-width: 768px)").matches
+);
+var themeAtom = Object.assign(
+  atom(
+    (get) => get(themeStorageAtom),
+    (get, set, update) => {
+      const current = get(themeStorageAtom);
+      const next = typeof update === "function" ? update(current) : update;
+      set(themeStorageAtom, next);
+      applyDashboardTheme(next);
+    }
+  ),
+  {
+    onMount(setTheme) {
+      setTheme((current) => current);
+    }
+  }
+);
+var canLogoutAtom = atom((get) => {
+  if (!get(authRequiredAtom)) return false;
+  const client = get(clientAtom);
+  return typeof client.logout === "function";
+});
+var logoutAtom = atom(null, async (get, set) => {
+  const client = get(clientAtom);
+  if (client.logout) await client.logout();
+  await set(authAtom, { type: "check" });
+});
+var enableThemeTransitionsFrame;
+function applyDashboardTheme(theme) {
+  if (typeof document === "undefined") return;
+  const { body, documentElement } = document;
+  if (body) {
+    body.dataset.disableTransition = "true";
+    void body.offsetWidth;
+    if (enableThemeTransitionsFrame)
+      cancelAnimationFrame(enableThemeTransitionsFrame);
+    enableThemeTransitionsFrame = requestAnimationFrame(() => {
+      enableThemeTransitionsFrame = requestAnimationFrame(() => {
+        body.removeAttribute("data-disable-transition");
+        enableThemeTransitionsFrame = void 0;
+      });
+    });
+  }
+  if (theme === "system") documentElement.removeAttribute("data-theme");
+  else documentElement.dataset.theme = theme;
+}
+export {
+  canLogoutAtom,
+  entrySidebarOpenAtom,
+  logoutAtom,
+  themeAtom
+};