@graphite-sports/sdk 0.3.0 → 0.5.0

package/index.d.ts

@@ -3,6 +3,7 @@ import { ColumnDef } from '@tanstack/react-table';
 import { ColumnHelper } from '@tanstack/table-core';
 import { ColumnVisibilityState } from '@tanstack/react-table';
 import { ComponentProps } from 'react';
+import { ComponentType } from 'react';
 import { CSSProperties } from 'react';
 import type { DataTag } from '@tanstack/react-query';
 import { FC } from 'react';
@@ -13,12 +14,14 @@ import { KeyboardEventHandler } from 'react';
 import { OnChangeFn } from '@tanstack/react-table';
 import { default as React_2 } from 'react';
 import * as React_3 from 'react';
+import type { ReactElement } from 'react';
 import { ReactNode } from 'react';
 import type { Ref } from 'react';
 import { RefObject } from 'react';
 import { RowData } from '@tanstack/react-table';
 import { RowModel } from '@tanstack/table-core';
 import { SortingState } from '@tanstack/react-table';
+import { SVGProps } from 'react';
 import { Tab } from '@headlessui/react';
 import { TabGroup } from '@headlessui/react';
 import { Table as Table_2 } from '@tanstack/table-core';
@@ -414,15 +417,6 @@ declare interface components {
             classId: components["schemas"]["ClassId"];
             eventId: components["schemas"]["EventId"];
         };
-        AddClassesMutation: {
-            classDtos: components["schemas"]["ClassDTO"][];
-            eventId: components["schemas"]["EventId"];
-            /**
-             * @description The classes get ids derived from it, see [ClassId::nth_of_seed]. Random, picked by the endpoint; reusing a seed
-             *      reproduces the same ids.
-             */
-            idSeed: components["schemas"]["Seed"];
-        };
         /** @description <C extends {}, P extends Primitive, S extends Sorted|Unsorted>(Table<C, S>, P) -> (Table<C & {<self.key>: P}, S>) */
         AddColumnsNode: {
             columns: string[];
@@ -532,10 +526,23 @@ declare interface components {
              *      Later dependencies expect earlier ones to exist.
              */
             dependencies: components["schemas"]["Archive"][];
-            /** Format: uuid */
+            /**
+             * Format: uint32
+             * @description Always [ENGINE_VERSION]: deserializing migrates older archives.
+             */
+            engineVersion: number;
+            /**
+             * Format: uuid
+             * @description The template the entry belongs to: installing it links the entity to it and reuses the entity of the event
+             *      installed from it before, see [template_origin](crate::graphite_engine::template_origin). Without one, the entity
+             *      is installed as a plain editable entity. Ignored for [ArchiveData::Group].
+             */
+            templateOrigin?: string | null;
+            /**
+             * Format: uuid
+             * @description Identifies the entry within the archive, see [Wiring]. Importing derives the ids of the entities from it.
+             */
             uuid: string;
-            /** @description The version of the archive system at time of creation of this archive. */
-            writtenWithVersion: components["schemas"]["SemVer"];
         };
         ArchiveData: {
             /** @constant */
@@ -711,8 +718,7 @@ declare interface components {
         ClassGender: "female-only" | "male-only" | "all-genders";
         /**
          * Format: uuid
-         * @description Identifies a class. Random ([Self::new_random]) from the endpoint, [Self::nth_of_seed] for `AddClassesMutation`,
-         *      or derived by `ImportArchiveMutation`.
+         * @description Identifies a class. Random ([Self::new_random]) from the endpoint, or derived by `ImportArchiveMutation`.
          *      Deserializing one only yields a reference to an existing class; it does not check that it exists.
          */
         ClassId: ClassId;
@@ -1240,11 +1246,6 @@ declare interface components {
              */
             nodeUuidSeed: components["schemas"]["Seed"];
         };
-        DuplicateGameFormatMutation: {
-            /** @description The id of the new copy, see [GameFormatId::new_random]. It must not exist yet. */
-            copyId: components["schemas"]["GameFormatId"];
-            gameFormatId: components["schemas"]["GameFormatId"];
-        };
         /** @description A single encoding definition applied to a single schema property. */
         Encoding: {
             /**
@@ -1607,6 +1608,8 @@ declare interface components {
             /** Format: date-time */
             updatedAt?: string | null;
         };
+        /** @description A value of the local store or the extension store, at most 64 KiB. */
+        ExtensionValue: string;
         /** @description Allows referencing an external resource for extended documentation. */
         ExternalDocumentation: {
             /**
@@ -2571,13 +2574,6 @@ declare interface components {
         /** @enum {string} */
         HeaderStyle: "simple";
         ImportArchiveError: {
-            /** @constant */
-            type: "incompatible-version";
-            data: {
-                got: components["schemas"]["SemVer"];
-                required: string;
-            };
-        } | {
             /** @constant */
             type: "invalid-archive";
             data: components["schemas"]["InvalidArchiveError"];
@@ -2596,12 +2592,6 @@ declare interface components {
         ImportArchiveMutation: {
             archive: components["schemas"]["Archive"];
             eventId: components["schemas"]["EventId"];
-            /**
-             * @description Links the installed entities to their archive entries and reuses entries installed before, see
-             *      [template_origin](crate::graphite_engine::template_origin). False for log entries written before linking existed.
-             * @default false
-             */
-            linkTemplate: boolean;
             /**
              * @description When `Some`, regenerates format node ids from this seed (deterministic log replay).
              *      When `None`, preserves archive node ids — for one-shot imports such as format tests.
@@ -2791,10 +2781,6 @@ declare interface components {
             /** @constant */
             type: "rename-game-format";
             data: components["schemas"]["RenameGameFormatMutation"];
-        } | {
-            /** @constant */
-            type: "duplicate-game-format";
-            data: components["schemas"]["DuplicateGameFormatMutation"];
         } | {
             /** @constant */
             type: "delete-game-format";
@@ -2807,10 +2793,6 @@ declare interface components {
             /** @constant */
             type: "add-class";
             data: components["schemas"]["AddClassMutation"];
-        } | {
-            /** @constant */
-            type: "add-classes";
-            data: components["schemas"]["AddClassesMutation"];
         } | {
             /** @constant */
             type: "rename-class";
@@ -2819,6 +2801,10 @@ declare interface components {
             /** @constant */
             type: "update-class";
             data: components["schemas"]["UpdateClassMutation"];
+        } | {
+            /** @constant */
+            type: "update-class-state";
+            data: components["schemas"]["UpdateClassStateMutation"];
         } | {
             /** @constant */
             type: "delete-class";
@@ -2991,7 +2977,7 @@ declare interface components {
         LogId: LogId;
         LogsQuery: {
             after: components["schemas"]["LogId"];
-            /** Format: int64 */
+            /** Format: uint32 */
             limit: number;
         };
         /**
@@ -4582,10 +4568,6 @@ declare interface components {
             hash: number[];
             id: components["schemas"]["LogId"];
         };
-        ReplicationProgressPath: {
-            /** Format: uuid */
-            taskId: string;
-        };
         ReplicationTargetMultipart: {
             /** Format: binary */
             file: Blob;
@@ -5325,6 +5307,10 @@ declare interface components {
             /** @constant */
             type: "detached";
         };
+        TaskPathVariables: {
+            /** Format: uuid */
+            taskId: string;
+        };
         TaskProgressDTO: {
             /** @constant */
             type: "in-progress";
@@ -5355,6 +5341,11 @@ declare interface components {
             /** @constant */
             type: "failed";
             data: {
+                /**
+                 * Format: uint
+                 * @description The index of the log entry that failed, for tasks that apply log entries.
+                 */
+                entry?: number | null;
                 error: string;
             };
         };
@@ -5659,6 +5650,9 @@ declare interface components {
         TypeParameters_for_Type_and_ParamRef: {
             [key: string]: components["schemas"]["TypeParameter_for_Type_and_ParamRef"];
         };
+        UninstalledExtensionPath: {
+            extensionIdent: components["schemas"]["ExtensionIdentifier"];
+        };
         /** @enum {string} */
         UniqueBibStrategy: "increment" | "lowest-free";
         /** @description Makes a linked entity editable again. */
@@ -5673,6 +5667,11 @@ declare interface components {
             classDto: components["schemas"]["ClassDTO"];
             id: components["schemas"]["ClassId"];
         };
+        /** @description Changes only the state of a class, which is event data and so also changes on classes linked to a template. */
+        UpdateClassStateMutation: {
+            classId: components["schemas"]["ClassId"];
+            state: components["schemas"]["TableState"];
+        };
         UpdateCompetitorMutation: {
             competitorDto: components["schemas"]["CompetitorDTO"];
             competitorId: components["schemas"]["CompetitorId"];
@@ -5769,6 +5768,13 @@ declare interface components {
         ValidationErrorKind_for_Type: ValidationErrorKind<Type>;
         /** @description A validation error with its location and kind. */
         ValidationError_for_Type: ValidationError<Type>;
+        ValueBody: {
+            value: components["schemas"]["ExtensionValue"];
+        };
+        ValuePath: {
+            extensionIdent: components["schemas"]["ExtensionIdentifier"];
+            key: string;
+        };
         /**
          * Important
          * @description Changes in here are breaking changes for logs
@@ -5857,6 +5863,8 @@ export declare function confirmDeleteItem(modalControls: ModalControls, itemName
  */
 export declare type ConstructorParams<T, R = ParamRef> = Record<string, TypeExpr<T, R>>;
 
+export declare type ContentInEventFolderDTO = components['schemas']['ContentInEventFolderDTO'];
+
 export declare interface ContextWasm {
     values: Record<string, Value<Primitive>>;
 }
@@ -5911,6 +5919,8 @@ export declare interface DialogButton<T> {
     theme?: 'primary' | 'default' | 'danger';
 }
 
+export declare type DraggableChildProps = React_2.HTMLAttributes<HTMLElement> & React_2.RefAttributes<HTMLElement>;
+
 /** Spelled out because the inferred `queryOptions` type references TanStack's unexported `dataTagSymbol`, which breaks the SDK's declaration rollup. */
 export declare type EngineQueryOptions<T> = UnusedSkipTokenOptions<T, Error, T, readonly unknown[]> & {
     queryKey: DataTag<readonly unknown[], T, Error>;
@@ -5921,6 +5931,8 @@ export declare type EngineQueryOptions<T> = UnusedSkipTokenOptions<T, Error, T,
  */
 declare type ErasedScopedTypeRef<T> = { type: "Param"; data: ParamRef } | { type: "ScopedExpr"; data: { expr: TypeExpr<T, ErasedScopedTypeRef<T>> } };
 
+export declare const eventFoldersByEventQueryOptions: (workspaceId: CommonWorkspaceId, eventId: EventId) => EngineQueryOptions<ContentInEventFolderDTO[]>;
+
 export declare type EventId = Brand<string, 'eventId'>;
 
 export declare interface EventPath {
@@ -5960,8 +5972,26 @@ export declare function extensionContribution<K extends keyof ExtensionContribut
 export declare type ExtensionContributions = {
     'game-format-page-bottom': GameFormatPageContribution;
     'game-page': GamePageContribution;
+    'table-drop': TableDropContribution;
 };
 
+/**
+ * Makes `children` draggable with `payload`. Dropping it onto a table hands `payload` to the `table-drop`
+ * contributions of the calling extension, and to no other extension's.
+ */
+export declare function ExtensionDraggable({ payload, children }: {
+    payload: string;
+    children: ReactElement<DraggableChildProps>;
+}): JSX.Element;
+
+/** What the host lends to extension callbacks that run outside of the extension's components. */
+export declare interface ExtensionHost {
+    /** Same as {@link useExtensionBackend}. */
+    backend: (path: string, init?: RequestInit) => Promise<Response>;
+    /** Modals whose content can use the extension's hooks, like {@link useExtensionBackend}. */
+    modal: ModalControls;
+}
+
 export declare type ExtensionInjectPlaceKey = keyof ExtensionContributions;
 
 /**
@@ -6009,7 +6039,7 @@ export declare interface ExtensionSidebarContribution {
 
 export declare type ExtensionSidebarProps = EventPath;
 
-declare interface FieldTypeWithDefault {
+export declare interface FieldTypeWithDefault {
     fieldType: TypeExpr<Type>;
     /**
      * Validated to be a subtype of field_type
@@ -6146,6 +6176,17 @@ export declare const getCompetitorsQO: (workspaceId: CommonWorkspaceId, eventId:
 
 export declare const getGameTableResolvedByGameQO: (workspaceId: CommonWorkspaceId, eventId: EventId, gameID: GameId, tableKind: "EntryList" | "ResultList") => EngineQueryOptions<ResolvedTableDTO>;
 
+/**
+ * The table as nodes see it, with the rows they don't see in `hiddenRows`.
+ */
+export declare const getGameTableResolvedQueryOptions: (workspaceId: CommonWorkspaceId, eventId: EventId, tableId: TableId) => EngineQueryOptions<ResolvedTableDTO>;
+
+export declare const getGameTablesByEventQueryOptions: (workspaceId: CommonWorkspaceId, eventId: EventId) => EngineQueryOptions<Map<TableId, TableDAO>>;
+
+export declare const getStandaloneTablesByEventQueryOptions: (workspaceId: CommonWorkspaceId, eventId: EventId) => EngineQueryOptions<Map<TableId, TableDAO>>;
+
+export declare const getTableByIdQueryOptions: (workspaceId: CommonWorkspaceId, eventId: EventId, tableId: TableId) => EngineQueryOptions<TableWithType>;
+
 /**
  * Location of a validation error in the graph.
  */
@@ -6209,8 +6250,17 @@ export declare type Locales = 'de' | 'en';
  */
 export declare type LocalParamID = number;
 
+export declare type LogEntry = components['schemas']['LogEntry'];
+
 declare type LogId = Brand<number, 'logId'>;
 
+/** One step of a log batch: its entries stay together and in order. */
+export declare interface LogOperation {
+    /** Names the operation when one of its entries fails. */
+    name: string;
+    entries: LogEntry[];
+}
+
 export declare type MergePathParams<A, B> = {
     [K in keyof A | keyof B]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never;
 };
@@ -6320,6 +6370,21 @@ declare interface NoSupertypeLayer<T> {
 
 declare type NoSupertypeLayerReason = "UnknownTypeParam" | "NodeSignatureInputsVarg" | "NodeSignatureInputs" | "NodeSignatureOutputs" | "NodeSignatureTags" | "NodeSignatureRequiredTags" | "PortTypesVarg" | "PortTypesArity" | "PortTypesPort" | "Index" | "ConstructorArity" | "ConstructorParam";
 
+/**
+ * The handle sticking out of the west edge of a panel, vertically centered. It is also the only thing left of the
+ * panel once it is hidden.
+ */
+export declare function NotchButton({ direction, label, onClick, className, children }: NotchButtonProps): JSX.Element;
+
+export declare interface NotchButtonProps {
+    /** Where the chevron points: out of the panel to hide it, back into it to bring it in. */
+    direction: 'left' | 'right';
+    label: string;
+    onClick: () => void;
+    className?: string;
+    children?: ReactNode;
+}
+
 export declare function Note({ children, className }: NoteProps): JSX.Element;
 
 export declare interface NoteProps {
@@ -6410,6 +6475,43 @@ export declare type Primitive = never;
 
 declare function primValueToTypeExpr(value: Value<Primitive>): TypeExpr<Type, ParamRef>;
 
+/**
+ * Replaces the rows a table holds on layer one.
+ *
+ * Only for tables whose layer one belongs to the user - a table filled by nodes has to be
+ * changed through {@see postRowMutations} instead, so their rows stay intact.
+ */
+export declare function putTableRows(workspaceId: CommonWorkspaceId, eventId: EventId, tableId: TableId, rows: Row[]): Promise<{
+    type: "unknown-error";
+} | {
+    type: "success";
+    data: undefined;
+} | {
+    type: "error";
+    error: {
+        type: "table-is-referenced";
+        data: components["schemas"]["TableId"];
+    } | {
+        type: "game-table-is-managed";
+        data: components["schemas"]["TableId"];
+    } | {
+        type: "shape-is-incompatible";
+    } | {
+        type: "cannot-update-kind";
+    } | {
+        type: "game-has-table-of-kind";
+        data: [components["schemas"]["GameId"], components["schemas"]["TableKind"]];
+    } | {
+        type: "column-validation-error";
+        data: components["schemas"]["RecordValueTypeValidationError"];
+    } | {
+        type: "row-not-hidden";
+        data: [components["schemas"]["TableId"], components["schemas"]["CompetitorId"]];
+    };
+}>;
+
+export declare type PutTableRowsResponse = Awaited<ReturnType<typeof putTableRows>>;
+
 export declare interface QueryCodec<T> {
     parse(value: string): T | null;
     serialize(value: T): string;
@@ -6445,7 +6547,7 @@ declare interface RecordTypeHelper<R = ParamRef> {
     properties: Record<string, TypeExpr<Type, R>>;
 }
 
-declare interface RecordTypeWithDefaults {
+export declare interface RecordTypeWithDefaults {
     properties: Record<string, FieldTypeWithDefault>;
 }
 
@@ -6519,7 +6621,7 @@ export declare interface RouterLocation {
 /**
  * Rows can only be created and moved by this crate, so that their [Origin] stays truthful.
  */
-declare interface Row {
+export declare interface Row {
     /**
      * Unique per table
      */
@@ -6585,6 +6687,65 @@ export declare type Shortcut = readonly string[];
  */
 export declare function showDialog<T>(modal: ModalControls, buttons: DialogButton<T>[], content: ReactNode): Promise<T | null>;
 
+/**
+ * A panel as a column of its own, next to the content. Keeping it out of the content gives toolbars the whole
+ * width, and collapsing it hands the space back. Hidden on mobile, see {@link SidePanelDrawer}.
+ */
+export declare function SidePanelDock({ storageKey, icon: Icon, badge, expandLabel, children }: SidePanelDockProps): JSX.Element;
+
+export declare interface SidePanelDockProps {
+    /** Remembers whether the panel is open. */
+    storageKey: string;
+    icon: SidePanelIcon;
+    /** Shown on the notch while the panel is hidden. */
+    badge?: ReactNode;
+    expandLabel: string;
+    children: (onClose: () => void) => ReactNode;
+}
+
+/** On mobile a panel has no room of its own, so it waits behind a button and slides in over the content. */
+export declare function SidePanelDrawer({ icon: Icon, label, title, badge, closeLabel, buttonClassName, children, }: SidePanelDrawerProps): JSX.Element;
+
+export declare interface SidePanelDrawerProps {
+    icon: SidePanelIcon;
+    label: string;
+    title: string;
+    badge?: ReactNode;
+    closeLabel: string;
+    /** Where the button opening the drawer sits. */
+    buttonClassName?: string;
+    children: (onClose: () => void) => ReactNode;
+}
+
+export declare function SidePanelFooterButton({ onClick, disabled, children }: SidePanelFooterButtonProps): JSX.Element;
+
+export declare interface SidePanelFooterButtonProps {
+    onClick: () => void;
+    disabled: boolean;
+    children: string;
+}
+
+/** A panel with a title, a scrolling body and an optional footer. The notch on its west edge closes it. */
+export declare function SidePanelFrame({ variant, icon: Icon, title, meta, closeLabel, onClose, footer, className, children, }: SidePanelFrameProps): JSX.Element;
+
+export declare interface SidePanelFrameProps {
+    /** Docked next to the content, or floating above it as the mobile drawer. */
+    variant: SidePanelVariant;
+    icon: SidePanelIcon;
+    title: string;
+    /** Shown at the right of the title, like how many items are selected. */
+    meta?: ReactNode;
+    closeLabel: string;
+    onClose: () => void;
+    footer?: ReactNode;
+    className?: string;
+    children: ReactNode;
+}
+
+export declare type SidePanelIcon = ComponentType<SVGProps<SVGSVGElement>>;
+
+export declare type SidePanelVariant = 'dock' | 'drawer';
+
 declare type Sorted = Brand<'sorted', 'sorted'>;
 
 /**
@@ -6613,6 +6774,25 @@ export declare enum StorageType {
  */
 declare type Table<SortingState, M = NoMetadata> = { rows: Rows<SortingState> } & M;
 
+export declare type TableDAO = components['schemas']['TableDAO'];
+
+/**
+ * Accepts payloads dragged with {@link ExtensionDraggable} of the same extension onto tables: standalone tables,
+ * and the entry and result tables of games. The first contribution whose `canDrop` accepts a payload takes it;
+ * payloads that none accepts can't be dropped.
+ */
+export declare interface TableDropContribution {
+    canDrop(payload: string, target: TableDropTarget): boolean;
+    onDrop(payload: string, target: TableDropTarget, host: ExtensionHost): void | Promise<void>;
+    /** Shown on the highlighted drop area. */
+    label?: Record<Locales, string>;
+}
+
+/** `table.variant` tells standalone and game tables apart, `table.tableKind` entry and result tables. */
+export declare type TableDropTarget = EventPath & {
+    table: TableDAO;
+};
+
 export declare type TableId = Brand<string, 'tableId'>;
 
 export declare interface TableProps<TData extends RowData> {
@@ -6657,6 +6837,8 @@ export declare type TableSorting = "unsorted" | "sorted";
 
 declare type TableState = number;
 
+export declare type TableWithType = components['schemas']['TableWithType'];
+
 export declare type TimeDelta = components['schemas']['TimeDeltaSchema'];
 
 export declare const TimeDeltaInput: FC<TimeDeltaInputProps>;
@@ -6737,7 +6919,7 @@ declare type Unsorted_2 = null;
 export declare function useEngineLocale(): Locales;
 
 /** Returns a `fetch` for `path` (relative, e.g. `"items"`) on the calling extension's own backend in the current event. */
-export declare function useExtensionBackend(): (path: string, init?: RequestInit) => Promise<Response>;
+export declare function useExtensionBackend(): ExtensionHost['backend'];
 
 /** The identifier the calling extension is installed under, e.g. the key of its `extensionData`. */
 export declare function useExtensionIdentifier(): string;
@@ -6761,6 +6943,12 @@ export declare function usePersistedState<S>(storageKey: string, initialState: S
 /** Hook to use the router context. Must be called within a <Router> provider. */
 export declare function useRouter(): RouterContextType;
 
+/**
+ * Returns a function that applies the entries of all operations in one all-or-nothing `POST /log` with a progress modal
+ * and reports a failure, like `runLogBatch`, with the modals and translations of the calling component.
+ */
+export declare function useRunLogBatch(): (workspaceId: CommonWorkspaceId, operations: LogOperation[], label: ReactNode) => Promise<boolean | null>;
+
 /** The `:` params that are uuids, by name. All other `:` params are numbers. */
 declare type UuidPathParams = {
     classId: ClassId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphite-sports/sdk",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "license": "MIT",
   "repository": "github:Graphite-sports/starter-extension",
   "homepage": "https://github.com/Graphite-sports/starter-extension",