alinea 2.0.0-preview.9 → 2.0.0-rc2

package/dist/dashboard/atoms/entryTable.js

@@ -0,0 +1,43 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/atoms/entryTable.ts
+import { Entry } from "alinea/core/Entry";
+import { Permission } from "alinea/core/Role";
+import { configAtom, graphAtom } from "./core.js";
+import { withLinkedEntries } from "./explorer.js";
+import { shaAtom } from "./graph.js";
+import { loadColumnValues } from "./overview.js";
+import { policyAtom } from "./user.js";
+var rowSelect = {
+  id: Entry.id,
+  status: Entry.status,
+  main: Entry.main,
+  title: Entry.title,
+  path: Entry.path,
+  url: Entry.url,
+  type: Entry.type,
+  workspace: Entry.workspace,
+  root: Entry.root,
+  locale: Entry.locale,
+  parentId: Entry.parentId,
+  parents: Entry.parents,
+  index: Entry.index,
+  data: Entry.data
+};
+async function loadEntryTableRows(get, query, overview) {
+  get(shaAtom);
+  const config = get(configAtom);
+  const graph = get(graphAtom);
+  const policy = get(policyAtom);
+  const found = await graph.find({
+    ...query,
+    groupBy: Entry.id,
+    select: rowSelect
+  });
+  const readable = found.filter((row) => policy.canRead(row)).map((row) => ({ ...row, hasChildren: false }));
+  const rows = await loadColumnValues(config, graph, overview, readable);
+  return withLinkedEntries(get, overview, rows, Permission.Read, false);
+}
+export {
+  loadEntryTableRows
+};

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

@@ -1,25 +1,22 @@
+import type { DragTypes, DropTarget, Key } from 'alinea/components';
+import { Config } from 'alinea/core/Config';
 import { type EntryStatus } from 'alinea/core/Entry';
 import type { EntryFields } from 'alinea/core/EntryFields';
-import { Field } from 'alinea/core/Field';
+import { type OpenFilter } from 'alinea/core/Filter';
 import type { Filter } from 'alinea/core/Filter';
-import { MediaFile, MediaLibrary } from 'alinea/core/media/MediaTypes';
-import type { OrderBy } from 'alinea/core/OrderBy';
+import type { GraphQuery } from 'alinea/core/Graph';
+import type { OverviewSort } from 'alinea/core/Overview';
+import { Permission, type Policy } from 'alinea/core/Role';
 import type { RootData } from 'alinea/core/Root';
-import { type Atom, type PrimitiveAtom, type WritableAtom } from 'jotai';
-import type { ComponentType, SetStateAction } from 'react';
-import type { DragItem, DragTypes, DropOperation, DropTarget } from '@react-types/shared';
-import type { DroppableCollectionOnItemDropEvent, Key } from 'react-aria-components';
-export declare const dashboardEntryOverviewColumnCount = 5;
+import { Type } from 'alinea/core/Type';
+import { type Atom, type Getter, type PrimitiveAtom, type WritableAtom } from 'jotai';
+import type { ComponentType, ReactNode, SetStateAction } from 'react';
+import { type OverviewFilterSelection, type OverviewFilterState, type OverviewState } from './overview.js';
 /** The best ranked matches a search loads into the explorer. */
 export declare const searchResultLimit = 100;
 export type ExplorerView = 'card' | 'row';
-export type ExplorerSortBy = 'title' | 'path' | 'size' | 'id' | 'index';
-export type ExplorerSortDirections = 'asc' | 'desc';
-export interface ExplorerSort {
-    sortBy: ExplorerSortBy;
-    direction: ExplorerSortDirections;
-}
-export type ExplorerTypeFilters = typeof MediaFile | typeof MediaLibrary;
+/** Where results are listed from: the root, its workspace or all workspaces */
+export type ExplorerScope = 'root' | 'workspace' | 'everything';
 export interface ExplorerLocation {
     workspace: string;
     root?: string;
@@ -30,23 +27,37 @@ export interface ExplorerLimitLocation {
     workspace: string;
     root: string;
 }
+export declare function constrainLocation(location: ExplorerLocation, limits: Array<ExplorerLimitLocation> | undefined): ExplorerLocation;
 export interface ExplorerOptions {
     allowAllWorkspaces?: boolean;
     autoSelectFirstItem?: boolean;
     breadcrumbs?: boolean;
+    /** Entries that match the condition can be selected when this allows it */
+    canSelect?: (item: ExplorerItemData) => boolean;
     condition?: Filter<EntryFields>;
-    defaultOrderBy?: Atom<OrderBy | Array<OrderBy> | undefined>;
     enableNavigation?: boolean;
     initialView?: ExplorerView;
     initialResultMode?: ExplorerResultMode;
-    initialSearchScope?: 'workspace' | 'everything';
+    initialSearchScope?: ExplorerScope;
     location?: ExplorerLocation;
     limitLocations?: Array<ExplorerLimitLocation>;
+    /** Lists only the media roots, for pickers of files and images */
+    media?: boolean;
     mode?: 'browse' | 'search';
     nestedNavigation?: boolean;
+    /**
+     * Entries are listed when the policy allows this permission on them,
+     * defaults to read. Pickers list what can be explored.
+     */
+    permission?: Permission;
     pickChildren?: boolean;
     rootData?: Atom<RootData>;
-    treeItems?: (locale: string | null, location: ExplorerLocation) => Atom<Array<ExplorerTreeItem>>;
+    /**
+     * Keeps the scroll offset of the listed results by `explorerScrollKey`,
+     * share it between explorers that list the same locations. Defaults to state
+     * kept by the explorer.
+     */
+    scrollOffset?: (key: string) => PrimitiveAtom<number>;
     treeReady?: (locale: string | null, location: ExplorerLocation) => Atom<Promise<unknown>>;
     selectedLocaleAtom?: WritableAtom<string | null, [
         SetStateAction<string | null>
@@ -54,40 +65,112 @@ export interface ExplorerOptions {
     selectedLocale?: string | null;
     selectionMode?: 'none' | 'single' | 'multiple';
     selectionBehavior?: 'toggle' | 'replace';
+    /**
+     * The column the editor sorted by, defaults to state kept by the explorer.
+     * Page explorers keep it in the url.
+     */
+    sortState?: WritableAtom<OverviewSort | undefined, [
+        OverviewSort | undefined
+    ], void>;
+    /**
+     * The filter options the editor picked, defaults to state kept by the
+     * explorer. The explorers of a root share them.
+     */
+    filterState?: PrimitiveAtom<OverviewFilterSelection>;
+    /**
+     * The key of the tab the editor picked, defaults to state kept by the
+     * explorer. Page explorers keep it in the url.
+     */
+    tabState?: WritableAtom<string | undefined, [string | undefined], void>;
     showSelectionControls?: boolean;
     initialSelection?: Array<string>;
+    /**
+     * Whether the matches in a folder are limited to its children, or cover
+     * the whole root. Defaults to the folder in browse mode.
+     */
     searchDepth?: 'current' | 'all';
     onAction?: (entry: ExplorerEntry) => void;
     onConfirm?: (selection: Array<string>, locale: string | null) => void;
     preselect?: boolean;
 }
-export interface ExplorerTreeItem {
+/** An entry on the way from the root to the listed location */
+export interface ExplorerPathEntry {
     id: string;
     title: string;
+}
+/** The entry whose children are listed */
+export interface ExplorerParent extends ExplorerPathEntry {
+    /** Its type, which decides what can be uploaded into it */
     type: string;
-    parentId: string | null;
-    hasChildren: boolean;
+    /** The ids of its parents, from the root down */
+    parents: Array<string>;
+    /** Its parents the editor can see, from the root down */
+    path: Array<ExplorerPathEntry>;
 }
 export type ExplorerResultMode = 'browse' | 'matches';
+type ExplorerQuery = GraphQuery<undefined, Type | undefined, undefined>;
+/** How the listed entries are ordered */
+export interface ExplorerSortState {
+    /** The column the editor sorted by */
+    requested?: OverviewSort;
+    /** The label of the order the editor picked */
+    label?: ReactNode;
+    /** The column shown as sorted, also for the parent's default order */
+    column?: OverviewSort;
+    /** Entries are listed in their stored order and can be reordered */
+    manual: boolean;
+}
 export interface ExplorerReadyPage {
     canUpload: boolean;
+    /**
+     * The file types an upload to the location can become. Media roots take
+     * uploads everywhere, see `Config.uploadCandidates`.
+     */
+    uploadTypes: Array<string>;
+    /**
+     * The condition of the selected tab and the picked filters, undefined when
+     * none applies
+     */
+    filter: OpenFilter<EntryFields> | undefined;
+    /** The filter options the listed entries match, by filter key */
+    filters: OverviewFilterSelection;
     isMedia: boolean;
     items: Array<ExplorerEntry>;
     locale: string | null;
     location: ExplorerLocation;
+    /** The entry the location lists the children of, undefined at a root */
+    parent: ExplorerParent | undefined;
+    overview: OverviewState;
+    /** The query of the listed entries, without selection and paging */
+    query: ExplorerQuery;
     root: ExplorerRootData;
     resultMode: ExplorerResultMode;
     search: string;
-    searchScope: 'workspace' | 'everything';
+    /** The scope the editor picked */
+    searchScope: ExplorerScope;
+    /** The scope the results are listed from */
+    scope: ExplorerScope;
     searchesEverything: boolean;
+    sort: ExplorerSortState;
+    /** The key of the tab shown, undefined when the overview has no tabs */
+    tab: string | undefined;
     view: ExplorerView;
 }
 export declare function explorerPageIsPending(page: ExplorerReadyPage, location: ExplorerLocation, locale: string | null): boolean;
+/**
+ * Identifies the listed results of a page: pages with the same key list the
+ * same entries in the same way and share their scroll offset
+ */
+export declare function explorerScrollKey(page: ExplorerReadyPage): string;
+/** The locations an explorer can list: those of the picker the policy allows */
+export declare function explorerLocations(config: Config, policy: Policy, options: ExplorerOptions): Array<ExplorerLimitLocation>;
 export interface ExplorerItemData {
     active?: boolean;
     createdAt?: number | null;
     id: string;
     status?: EntryStatus;
+    /** The version is the main one, a draft then was never published */
+    main?: boolean;
     title: string;
     path: string;
     updatedAt?: number | null;
@@ -98,6 +181,8 @@ export interface ExplorerItemData {
     locale: string | null;
     parentId: string | null;
     parents: Array<string>;
+    /** Set for entries seeded by the config, these can not move or be removed */
+    seeded?: string | null;
     parentEntries?: Array<{
         id: string;
         title: string;
@@ -110,12 +195,41 @@ export interface ExplorerItemData {
     index: string;
     data: Record<string, unknown>;
     hasChildren: boolean;
+    /** The values of the overview columns that are queried, by column key */
+    columns?: Record<string, unknown>;
+    /** Summaries of the entries linked from the overview columns, by id */
+    linked?: Record<string, ExplorerLinkedEntry>;
+    /** The first image found in the entry's fields */
+    thumbnail?: ExplorerLinkedEntry;
 }
-export interface DashboardEntryOverviewCell {
+/** What the explorer shows of an entry linked from another entry */
+export interface ExplorerLinkedEntry {
     id: string;
-    field: Field;
-    label: string;
-    value: unknown;
+    title: string;
+    /** A small data url preview of an image */
+    preview?: string;
+    averageColor?: string;
+}
+/**
+ * The id of the first image an entry links to, following the order of the
+ * type's fields and the items within them (eg. a gallery). Returns undefined
+ * if the entry has no images.
+ */
+export declare function explorerThumbnailId(type: Type, data: Record<string, unknown>): string | undefined;
+/**
+ * Loads the thumbnails and the entries linked from the overview columns of
+ * the given explorer items in a single query
+ */
+export declare function withLinkedEntries<Item extends ExplorerItemData>(get: Getter, overview: OverviewState, items: Array<Item>, permission?: Permission, thumbnails?: boolean): Promise<Array<Item>>;
+/** The selected entry can be moved to another parent */
+export declare function explorerItemCanMove(policy: Policy, item: ExplorerItemData): boolean;
+/** The selected entry can be deleted, in the language it is listed in */
+export declare function explorerItemCanDelete(policy: Policy, item: ExplorerItemData): boolean;
+export interface ExplorerSelectionActions {
+    /** The selected entries that are listed */
+    items: Array<ExplorerItemData>;
+    canMove: boolean;
+    canDelete: boolean;
 }
 export interface ExplorerRootData {
     icon: Atom<ComponentType>;
@@ -137,6 +251,10 @@ export declare class ExplorerEntryData {
         title: string;
         path: string;
         metadata: {
+            createdAt: number | null;
+            createdBy: import("../../field/metadata.js").MetadataAuditUser;
+            updatedAt: number | null;
+            updatedBy: import("../../field/metadata.js").MetadataAuditUser;
             aliases: import("../../field/metadata.js").MetadataAlias[];
         };
         location: string;
@@ -144,6 +262,7 @@ export declare class ExplorerEntryData {
         extension: string;
         size: number;
         hash: string;
+        sourceHash: string;
         alt: import("../../core/media/MediaAltField.js").MediaAltValue;
         width: number;
         height: number;
@@ -155,7 +274,8 @@ export declare class ExplorerEntryData {
         };
         thumbHash: string;
     } | null>;
-    overviewCells: Atom<DashboardEntryOverviewCell[]>;
+    linked: Atom<ReadonlyMap<string, ExplorerLinkedEntry>>;
+    thumbnail: Atom<ExplorerLinkedEntry | undefined>;
     constructor(item: Atom<ExplorerItemData>, _root: Atom<ExplorerRootData>, parents?: Array<ExplorerEntry>);
 }
 export declare class ExplorerEntry {
@@ -177,13 +297,16 @@ export declare class ExplorerAtoms {
     readonly location: WritableAtom<ExplorerLocation, [
         SetStateAction<ExplorerLocation>
     ], void>;
+    /** The id of the element that contains the results */
+    readonly resultsId: string;
     readonly allowAllWorkspaces: boolean;
     readonly selectionMode: "multiple" | "none" | "single";
     readonly selectionBehavior: "replace" | "toggle";
     readonly showSelectionControls: boolean;
     readonly breadcrumbs: boolean;
     readonly autoSelectFirstItem: boolean;
-    readonly rootScope: 'current' | 'workspace';
+    /** The scope results are listed from unless the editor picks a wider one */
+    readonly rootScope: 'root' | 'workspace';
     readonly hasRowAction: boolean;
     readonly mode: 'browse' | 'search';
     readonly hasSelection: boolean;
@@ -191,13 +314,18 @@ export declare class ExplorerAtoms {
     readonly searchDepth: "all" | "current";
     readonly supportsInlineExpansion: boolean;
     readonly pickChildren: boolean;
+    /** Whether folders can be browsed, besides listing filtered matches */
+    readonly canBrowse: boolean;
     readonly hasCondition: boolean;
+    readonly permission: Permission;
     readonly canSearchEverything: Atom<boolean>;
+    /** The scope the results are listed from */
+    readonly scope: Atom<ExplorerScope>;
     readonly searchesEverything: Atom<boolean>;
     search: PrimitiveAtom<string> & {
         init: string;
     };
-    searchScope: PrimitiveAtom<'workspace' | 'everything'>;
+    searchScope: PrimitiveAtom<ExplorerScope>;
     resultMode: WritableAtom<ExplorerResultMode, [ExplorerResultMode], void>;
     selection: PrimitiveAtom<'all' | Set<Key>>;
     expandedKeys: PrimitiveAtom<Set<Key>> & {
@@ -206,35 +334,77 @@ export declare class ExplorerAtoms {
     sidebarExpandedKeys: PrimitiveAtom<Set<string>> & {
         init: Set<string>;
     };
+    sidebarClosedKeys: PrimitiveAtom<Set<string>> & {
+        init: Set<string>;
+    };
+    /** The column the editor sorted by, undefined for the default order */
+    requestedSort: WritableAtom<OverviewSort | undefined, [
+        OverviewSort | undefined
+    ], void>;
+    /**
+     * The options the editor picked of the filters of the overview, by filter
+     * key. The page lists the ones that apply to its overview.
+     */
+    requestedFilters: PrimitiveAtom<OverviewFilterSelection>;
+    /** The key of the tab the editor picked, undefined for the first tab */
+    requestedTab: WritableAtom<string | undefined, [string | undefined], void>;
     selectedLocale: WritableAtom<string | null, [
         SetStateAction<string | null>
     ], void>;
     root: Atom<ExplorerRootData>;
-    parent: (location: ExplorerLocation, locale: string | null) => Atom<ExplorerEntry | undefined>;
     itemsReady: (locale: string | null) => Atom<Promise<Array<ExplorerEntry>>>;
     items: (locale: string | null) => Atom<Array<ExplorerEntry>>;
     pageReady: Atom<Promise<ExplorerReadyPage>>;
     page: Atom<ExplorerReadyPage | undefined>;
+    /**
+     * The scroll offset of the results of a page by its `explorerScrollKey`,
+     * restored when a page with the same key is shown again
+     */
+    scrollOffset: (key: string) => PrimitiveAtom<number>;
     constructor(location: WritableAtom<ExplorerLocation, [
         SetStateAction<ExplorerLocation>
     ], void>, options: ExplorerOptions, initialLocation: ExplorerLocation);
     isMedia: Atom<boolean>;
     view: WritableAtom<ExplorerView, [view: ExplorerView], void>;
-    sort: WritableAtom<ExplorerSort, [sortBy: ExplorerSortBy], void>;
-    filter: WritableAtom<ExplorerTypeFilters | undefined, [filter: ExplorerTypeFilters], void>;
+    /**
+     * The overview the list is loaded with: its columns, the values they
+     * query and the order. The page shows the columns that tell the loaded
+     * rows apart, see `pageReady`.
+     */
+    overview: Atom<Promise<OverviewState>>;
+    /**
+     * Picks an option of a filter, or unpicks it when picked. Options of
+     * filters that allow one replace the picked option.
+     */
+    toggleFilter: WritableAtom<null, [filter: OverviewFilterState, option: string], void> & {
+        init: null;
+    };
+    /** Unpicks the options of every filter */
+    clearFilters: WritableAtom<null, [], void> & {
+        init: null;
+    };
     get limitLocations(): ExplorerLimitLocation[] | undefined;
-    canUpload: Atom<boolean>;
+    /** The locations this explorer lists */
+    locations: Atom<ExplorerLimitLocation[]>;
     uploadsInCurrentFolder: Atom<import("../boot/ActivityEvent.js").Activity[]>;
     upload: WritableAtom<null, [files: ArrayLike<File> | Iterable<File>], Promise<void>> & {
         init: null;
     };
-    getItems: WritableAtom<null, [keys: Set<Key>], DragItem[]> & {
+    getDragData: WritableAtom<null, [keys: ReadonlySet<Key>], Record<string, string>[]> & {
+        init: null;
+    };
+    /** Entries can be dropped on a listed entry that holds children */
+    canDrop: WritableAtom<null, [target: DropTarget, types: DragTypes, locale: string | null], boolean> & {
         init: null;
     };
-    getDropOperation: WritableAtom<null, [target: DropTarget, types: DragTypes, allowedOperations: DropOperation[]], "cancel" | "move"> & {
+    /** Moves entries into the target entry */
+    moveInto: WritableAtom<null, [ids: Iterable<string>, target: DropTarget], Promise<void>> & {
         init: null;
     };
-    onItemDrop: WritableAtom<null, [event: DroppableCollectionOnItemDropEvent, locale: string | null], Promise<void>> & {
+    /**
+     * Moves entries before or after the target, in the order they are listed
+     */
+    reorder: WritableAtom<null, [ids: Iterable<string>, target: DropTarget, locale: string | null], Promise<void>> & {
         init: null;
     };
     onAction: WritableAtom<null, [entry: ExplorerEntry, locale: string | null], void> & {
@@ -246,6 +416,11 @@ export declare class ExplorerAtoms {
     onConfirm: WritableAtom<null, [locale?: string | null | undefined], void> & {
         init: null;
     };
+    /** The listed entries that are selected, and what can be done with them */
+    selectionActions: Atom<ExplorerSelectionActions>;
+    clearSelection: WritableAtom<null, [], void> & {
+        init: null;
+    };
     isExpanded: (entry: ExplorerEntry) => Atom<boolean>;
     isSelectable: (entry: ExplorerEntry) => Atom<boolean>;
     childrenReady: (entry: ExplorerEntry, locale: string | null) => Atom<Promise<ExplorerEntry[]>>;
@@ -256,3 +431,4 @@ export type DashboardEntry = ExplorerEntry;
 export type DashboardEntryData = ExplorerEntryData;
 export type DashboardExplorer = ExplorerAtoms;
 export type DashboardRoot = ExplorerRootData;
+export {};