@plitzi/plitzi-builder 0.37.2 → 0.37.3

package/dist/App.d.ts

@@ -8,6 +8,11 @@ export type AppProps = {
     includeSubscriptions?: boolean;
     userKey?: string;
     debugMode?: boolean;
+    /**
+     * Where the TypeScript worker the Functions panel types a space's code with is served — `plitzi-functions-worker.js`
+     * of this package, from wherever the host serves the builder's files. Absent, the panel edits and saves without it.
+     */
+    functionsWorkerUrl?: string;
 };
 declare const App: (props: AppProps) => import('react').JSX.Element;
 export default App;

package/dist/index.d.ts

@@ -28,6 +28,7 @@ export type PlitziBuilderProps = {
     externalStyle?: string;
     state?: object;
     debugMode?: boolean;
+    functionsWorkerUrl?: AppProps['functionsWorkerUrl'];
 };
 declare const PlitziBuilder: {
     (props: PlitziBuilderProps): import('react').JSX.Element;

package/dist/index.html

@@ -56,11 +56,12 @@
       render(
         'plitzi',
         {
-          webKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxIiwib3JpZ2lucyI6WyJodHRwczovL3dlYnNpdGUucGxpdHppLmFwcCIsImh0dHBzOi8vcGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDAiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMSIsImh0dHBzOi8vc3NyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc2VydmVyLnBsaXR6aS5sb2NhbCIsImh0dHA6Ly9sb2NhbGhvc3Q6MzAwMCIsImh0dHA6Ly9sb2NhbGhvc3Q6ODA4MCIsImh0dHA6Ly8xMjcuMC4wLjE6ODA4MCJdLCJpc3MiOiJodHRwczovL3NlcnZlci5wbGl0emkubG9jYWwiLCJhdWQiOlsiaHR0cHM6Ly9wbGl0emkubG9jYWwiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWwiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMCIsImh0dHBzOi8vYXBwLnBsaXR6aS5sb2NhbDozMDAxIiwiaHR0cHM6Ly9hcGkucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9zc3IucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9zZXJ2ZXIucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9tY3AucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hdXRoLnBsaXR6aS5sb2NhbCIsImh0dHA6Ly8xMjcuMC4wLjE6NTMwMCIsImh0dHA6Ly9sb2NhbGhvc3Q6NTE4MCJdLCJzY29wZSI6InNwYWNlOnJlbmRlciIsImlhdCI6MTc4OTg0OTYyMywianRpIjoiMmM0ZTRkNDI1NzEzMTI4YyIsIm5iZiI6MTc4OTg0OTYyM30.VKxz7K9A8tvKnCwWLnB02NgAQY7Oftr6NzAXH8v4nsU',
+          webKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxIiwib3JpZ2lucyI6WyJodHRwczovL3dlYnNpdGUucGxpdHppLmFwcCIsImh0dHBzOi8vcGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDAiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMSIsImh0dHBzOi8vc3NyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc2VydmVyLnBsaXR6aS5sb2NhbCIsImh0dHA6Ly9sb2NhbGhvc3Q6MzAwMCIsImh0dHA6Ly9sb2NhbGhvc3Q6ODA4MCIsImh0dHA6Ly8xMjcuMC4wLjE6ODA4MCIsImh0dHBzOi8vZGV2LnBsaXR6aS5jb20iLCJodHRwczovL3BsaXR6aS5jb20iLCJodHRwczovL3N0Zy5wbGl0emkuY29tIl0sImlzcyI6Imh0dHBzOi8vc2VydmVyLnBsaXR6aS5sb2NhbCIsImF1ZCI6WyJodHRwczovL3BsaXR6aS5sb2NhbCIsImh0dHBzOi8vYXBwLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vYXBwLnBsaXR6aS5sb2NhbDozMDAwIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDEiLCJodHRwczovL2FwaS5wbGl0emkubG9jYWwiLCJodHRwczovL3Nzci5wbGl0emkubG9jYWwiLCJodHRwczovL3NlcnZlci5wbGl0emkubG9jYWwiLCJodHRwczovL21jcC5wbGl0emkubG9jYWwiLCJodHRwczovL2F1dGgucGxpdHppLmxvY2FsIiwiaHR0cDovLzEyNy4wLjAuMTo1MzAwIiwiaHR0cDovL2xvY2FsaG9zdDo1MTgwIl0sInNjb3BlIjoic3BhY2U6cmVuZGVyIiwiaWF0IjoxNzkwMjEzMjg5LCJqdGkiOiJhZDgyN2EyMjliZjhlMzk3IiwibmJmIjoxNzkwMjEzMjg5fQ.dedpVVA5Nv3Xr7nEOZ8UmEJcIamF9AHGnLgqQyDV8-k',
           // The actor. Without it the builder loads and every write is refused, since authorization is
           // can(actor, space, permission). Both halves come from `yarn token 1 --user admin` in plitzi-sdk-server.
-          userKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxIiwiaXNzIjoiaHR0cHM6Ly9zZXJ2ZXIucGxpdHppLmxvY2FsIiwiYXVkIjpbImh0dHBzOi8vcGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDAiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMSIsImh0dHBzOi8vYXBpLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc3NyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc2VydmVyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vbWNwLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vYXV0aC5wbGl0emkubG9jYWwiLCJodHRwOi8vMTI3LjAuMC4xOjUzMDAiLCJodHRwOi8vbG9jYWxob3N0OjUxODAiXSwic2NvcGUiOiJ1c2VyIiwiZXhwIjoxNzg5OTA1NDg3LCJpYXQiOjE3ODk4MTkwODcsImp0aSI6ImQyZjAwNTE1ZTFiMzk1YzEiLCJuYmYiOjE3ODk4MTkwODd9.SGs05mrxeKWgi34XZ--vG_qtkwk8Pw7R2KEt5EU6rpc',
+          userKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxIiwiaXNzIjoiaHR0cHM6Ly9zZXJ2ZXIucGxpdHppLmxvY2FsIiwiYXVkIjpbImh0dHBzOi8vcGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDAiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMSIsImh0dHBzOi8vYXBpLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc3NyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc2VydmVyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vbWNwLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vYXV0aC5wbGl0emkubG9jYWwiLCJodHRwOi8vMTI3LjAuMC4xOjUzMDAiLCJodHRwOi8vbG9jYWxob3N0OjUxODAiXSwic2NvcGUiOiJ1c2VyIiwiZXhwIjoxNzkwMjg3MDg0LCJpYXQiOjE3OTAyMDA2ODQsImp0aSI6ImNiZWE3MDZlNzYyZGFiNGUiLCJuYmYiOjE3OTAyMDA2ODR9.IpPxIRFRi6KXz0yCC1fPQF6hLubU_7u0fTcgQohmB10',
           environment: 'main',
+          functionsWorkerUrl: '/plitzi-functions-worker.js',
           server: {
             basePath: '',
             // Dashboard

package/dist/modules/AI/components/ChatInput/components/ModelSelector/components/ModelOption/ModelOption.d.ts

@@ -2,7 +2,8 @@ import { AiModelInfo } from '../../../../../../types';
 export type ModelOptionProps = {
     model: AiModelInfo;
     isActive: boolean;
+    isHighlighted?: boolean;
     onSelect: (id: string) => void;
 };
-declare const ModelOption: ({ model, isActive, onSelect }: ModelOptionProps) => import('react').JSX.Element;
+declare const ModelOption: ({ model, isActive, isHighlighted, onSelect }: ModelOptionProps) => import('react').JSX.Element;
 export default ModelOption;

package/dist/modules/App/AppContainer/containers/ContainerFunctions.d.ts

@@ -0,0 +1,2 @@
+declare const ContainerFunctions: () => import('react').JSX.Element;
+export default ContainerFunctions;

package/dist/modules/App/AppContainer/containers/ContainerRuntime.d.ts

@@ -0,0 +1,2 @@
+declare const ContainerRuntime: () => import('react').JSX.Element;
+export default ContainerRuntime;

package/dist/modules/App/AppContainer/containers/ContainerVisitors.d.ts

@@ -0,0 +1,2 @@
+declare const ContainerVisitors: () => import('react').JSX.Element;
+export default ContainerVisitors;

package/dist/modules/App/AppContext.d.ts

@@ -12,6 +12,8 @@ export type AppContextValue = {
     setDisplayMode: Dispatch<SetStateAction<DisplayMode>>;
     mobilePreview: boolean;
     setMobilePreview: Dispatch<SetStateAction<boolean>>;
+    /** Where the Functions panel's TypeScript worker is served; empty when the host serves none. */
+    functionsWorkerUrl: string;
 };
 declare const AppContext: import('react').Context<AppContextValue>;
 export default AppContext;

package/dist/modules/App/AppMain.d.ts

@@ -13,6 +13,7 @@ export type AppMainProps = {
     state?: Record<string, unknown>;
     children?: ReactNode;
     debugMode?: boolean;
+    functionsWorkerUrl?: string;
 };
-declare const AppMain: ({ webKey, webId, userKey, instanceId, server, environment, includeSubscriptions, includeRealTime, externalStyle, debugMode }: AppMainProps) => import('react').JSX.Element;
+declare const AppMain: ({ webKey, webId, userKey, instanceId, server, environment, includeSubscriptions, includeRealTime, externalStyle, debugMode, functionsWorkerUrl }: AppMainProps) => import('react').JSX.Element;
 export default AppMain;

package/dist/modules/App/components/AppHeader/IssuesButton/IssuesButton.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('react').MemoExoticComponent<() => import('react').JSX.Element | null>;
+export default _default;

package/dist/modules/App/components/AppHeader/IssuesButton/helpers.d.ts

@@ -0,0 +1,4 @@
+import { IssuesLevel } from '../../../../Space/helpers/spaceIssues';
+export declare const LEVEL_TEXT: Record<IssuesLevel, string>;
+export declare const LEVEL_ICON: Record<IssuesLevel, string>;
+export declare const LEVEL_TITLE: Record<IssuesLevel, string>;

package/dist/modules/App/components/AppHeader/IssuesButton/index.d.ts

@@ -0,0 +1,3 @@
+import { default as IssuesButton } from './IssuesButton';
+export * from './IssuesButton';
+export default IssuesButton;

package/dist/modules/App/components/AppHeader/RuntimeIdleNotice/RuntimeIdleNotice.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('react').MemoExoticComponent<() => import('react').JSX.Element | null>;
+export default _default;

package/dist/modules/App/components/AppHeader/RuntimeIdleNotice/index.d.ts

@@ -0,0 +1 @@
+export { default } from './RuntimeIdleNotice';

package/dist/modules/App/components/AppHeader/RuntimeIdleNotice/timeLeftOf.d.ts

@@ -0,0 +1,3 @@
+/** Time left before a runtime stops, as the header counts it down: hours while there are any, then minutes. */
+declare const timeLeftOf: (seconds: number) => string;
+export default timeLeftOf;

package/dist/modules/Builder/components/BuilderOverlay/BuilderOverlayDrag.d.ts

@@ -1,6 +1,4 @@
 import { RefObject } from 'react';
-export declare const OVERLAY_MODE_NORMAL = "normal";
-export declare const OVERLAY_MODE_DRAG = "drag";
 export type BuilderOverlayDragProps = {
     refIframe: RefObject<HTMLIFrameElement | null>;
     sizeOffset?: number;

package/dist/modules/Builder/helpers/elementChain.d.ts

@@ -12,8 +12,7 @@ export type ElementLookup = Record<string, Element | undefined>;
  *
  * Walked through `parentId` rather than read off `rootId`, because the tree the panel opens is the chain of
  * PARENTS: revealing a match six levels down means opening all six, and `rootId` names only the far end of it. The
- * seen-set is not paranoia — a schema edited by two people at once can briefly describe a cycle, and without it
- * this loops forever inside a render.
+ * walk is sdk-schema's `parentChain`, the one every reader of the tree shares.
  */
 export declare const chainOf: (flat: ElementLookup, id: string) => {
     rootId: string;

package/dist/modules/Elements/ElementHelper.d.ts

@@ -10,3 +10,5 @@ export declare const getInitialItems: (parentId: string, items: string[] | undef
     directItems: Record<string, Element>;
     items: Record<string, Element>;
 };
+/** The catalog as the elements panel lists it: every definition whose label matches `filter`, grouped by category. */
+export declare const definitionsByCategory: (definitions: Record<string, ComponentDefinition>, filter: string) => Record<string, ComponentDefinition[]>;

package/dist/modules/Functions/Functions.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The space's own server code: its files, edited with TypeScript that knows the contract, saved as the draft
+ * — built and checked on the platform, problems shown where they are — and tried in the sandbox. The live site runs
+ * what the space was last published with. A project's `plitzi functions pull` edits the same files.
+ */
+declare const Functions: () => import('react').JSX.Element;
+export default Functions;

package/dist/modules/Functions/components/FunctionsDeclared/FunctionsDeclared.d.ts

@@ -0,0 +1,10 @@
+import { FunctionsManifest } from '@plitzi/sdk-shared';
+export type FunctionsDeclaredProps = {
+    manifest: FunctionsManifest;
+};
+/**
+ * What the saved code declares — its steps, its routes and every host it may reach — so whoever reviews the space sees
+ * what it does and where it goes without reading the code.
+ */
+declare const FunctionsDeclared: ({ manifest }: FunctionsDeclaredProps) => import('react').JSX.Element;
+export default FunctionsDeclared;

package/dist/modules/Functions/components/FunctionsDeclared/index.d.ts

@@ -0,0 +1,3 @@
+import { default as FunctionsDeclared } from './FunctionsDeclared';
+export * from './FunctionsDeclared';
+export default FunctionsDeclared;

package/dist/modules/Functions/components/FunctionsFiles/FunctionsFiles.d.ts

@@ -0,0 +1,11 @@
+export type FunctionsFilesProps = {
+    files: string[];
+    selected: string;
+    /** The files whose text differs from what was last saved. */
+    modified: string[];
+    onSelect: (file: string) => void;
+    onAdd: (file: string) => void;
+    onRemove: (file: string) => void;
+};
+declare const FunctionsFiles: ({ files, selected, modified, onSelect, onAdd, onRemove }: FunctionsFilesProps) => import('react').JSX.Element;
+export default FunctionsFiles;

package/dist/modules/Functions/components/FunctionsFiles/index.d.ts

@@ -0,0 +1,3 @@
+import { default as FunctionsFiles } from './FunctionsFiles';
+export * from './FunctionsFiles';
+export default FunctionsFiles;

package/dist/modules/Functions/components/FunctionsProblems/FunctionsProblems.d.ts

@@ -0,0 +1,8 @@
+import { FunctionsProblem } from '@plitzi/sdk-shared';
+export type FunctionsProblemsProps = {
+    problems: FunctionsProblem[];
+    onSelect: (file: string) => void;
+};
+/** What the last save found wrong, where it is: the build's and the platform's checks, before anything ran. */
+declare const FunctionsProblems: ({ problems, onSelect }: FunctionsProblemsProps) => import('react').JSX.Element;
+export default FunctionsProblems;

package/dist/modules/Functions/components/FunctionsProblems/index.d.ts

@@ -0,0 +1,3 @@
+import { default as FunctionsProblems } from './FunctionsProblems';
+export * from './FunctionsProblems';
+export default FunctionsProblems;

package/dist/modules/Functions/components/FunctionsTry/FunctionsTry.d.ts

@@ -0,0 +1,13 @@
+import { ActionRunReport, FunctionTaskManifest } from '@plitzi/sdk-shared';
+export type FunctionsTryProps = {
+    tasks: FunctionTaskManifest[];
+    /** Why it cannot run now — unsaved edits, say — or nothing. */
+    disabledReason?: string;
+    onTry: (task: string, params: Record<string, unknown>) => Promise<ActionRunReport | undefined>;
+};
+/**
+ * One task of the saved draft, run in the sandbox as you — the value it answers, what it logged, how long it took and
+ * why it failed. Its fetches and its writes are real, and it counts like any other run.
+ */
+declare const FunctionsTry: ({ tasks, disabledReason, onTry }: FunctionsTryProps) => import('react').JSX.Element;
+export default FunctionsTry;

package/dist/modules/Functions/components/FunctionsTry/index.d.ts

@@ -0,0 +1,3 @@
+import { default as FunctionsTry } from './FunctionsTry';
+export * from './FunctionsTry';
+export default FunctionsTry;

package/dist/modules/Functions/editor/functionsEnvironment.d.ts

@@ -0,0 +1,6 @@
+import { VirtualTypeScriptEnvironment } from '@typescript/vfs';
+/**
+ * The TypeScript a space's functions are checked with: the libs, the contract at `@plitzi/sdk-server/functions`, and
+ * nothing else — the space's own files are added as the editor opens and changes them.
+ */
+export declare const createFunctionsEnvironment: () => VirtualTypeScriptEnvironment;

package/dist/modules/Functions/editor/useFunctionsTypeScript.d.ts

@@ -0,0 +1,13 @@
+import { Extension } from '@codemirror/state';
+/** Where a file of the space's functions lives in the worker — the same root the worker keeps them under. */
+export declare const workerPathOf: (file: string) => string;
+/**
+ * The TypeScript worker for one open panel: started from where the host serves it, given every file of the space so
+ * their imports of each other resolve, and turned into the editor extensions for the file being edited. Without a
+ * worker URL, or before it is ready, there are no extensions — the editor still edits, and a save still checks.
+ */
+declare const useFunctionsTypeScript: (workerUrl: string, files: Record<string, string>) => {
+    ready: boolean;
+    extensionsFor: (file: string) => Extension[];
+};
+export default useFunctionsTypeScript;

package/dist/modules/Functions/helpers.d.ts

@@ -0,0 +1,11 @@
+import { FunctionsProblem } from '@plitzi/sdk-shared';
+/** What a space's functions start as: one file and one task already written, to change rather than to learn from blank. */
+export declare const STARTER_FILES: Record<string, string>;
+/** Where a problem is, as a person reads it: `lib/feed.ts:12:4`. */
+export declare const problemPlace: ({ file, line, column }: FunctionsProblem) => string;
+/** The params a Try sends, from what was typed: a JSON object, or the reason it is not one. */
+export declare const readParams: (text: string) => {
+    params: Record<string, unknown>;
+} | {
+    error: string;
+};

package/dist/modules/Functions/index.d.ts

@@ -0,0 +1,2 @@
+import { default as Functions } from './Functions';
+export default Functions;

package/dist/modules/Functions/useFunctions.d.ts

@@ -0,0 +1,14 @@
+import { ActionRunReport, FunctionsDraft, FunctionsSaveResult } from '@plitzi/sdk-shared';
+/**
+ * The space's functions draft, and the three things the panel does to it — save, remove, try — through the same
+ * operations a project's CLI and an agent use (`SpaceSaveFunctions`, `SpaceRemoveFunctions`, `SpaceTryFunction`).
+ */
+declare const useFunctions: () => {
+    draft: FunctionsDraft | undefined;
+    error: string;
+    isLoading: boolean;
+    save: (files: FunctionsDraft["files"]) => Promise<FunctionsSaveResult | undefined>;
+    remove: () => Promise<void>;
+    tryTask: (task: string, params: Record<string, unknown>) => Promise<ActionRunReport | undefined>;
+};
+export default useFunctions;

package/dist/modules/History/History.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The space's change history: every save of its schema and style, by whoever made it — a person, an agent, the
+ * autofix — newest first, with the published revisions marked where they fall. Read-only: it answers "what changed,
+ * who did it and what exactly", and never writes anything back.
+ */
+declare const History: () => import('react').JSX.Element;
+export default History;

package/dist/modules/History/components/ChangeEntry/ChangeEntry.d.ts

@@ -0,0 +1,7 @@
+import { ChangeEntry as Entry } from '@plitzi/sdk-shared';
+export type ChangeEntryProps = {
+    entry: Entry;
+};
+/** The fields an edit changed, each as `field: before → after`. Its line above already says what the entity is. */
+declare const ChangeEntry: ({ entry }: ChangeEntryProps) => import('react').JSX.Element;
+export default ChangeEntry;

package/dist/modules/History/components/ChangeEntry/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ChangeEntry } from './ChangeEntry';
+export * from './ChangeEntry';
+export default ChangeEntry;

package/dist/modules/History/components/ChangeGroup/ChangeGroup.d.ts

@@ -0,0 +1,10 @@
+import { ChangeGroup as Group } from '../../helpers';
+export type ChangeGroupProps = {
+    group: Group;
+};
+/**
+ * A row of the timeline: who, from where and when, and what it did — one line per thing. Unfolded, every save it groups
+ * on its own, with the fields each one changed.
+ */
+declare const ChangeGroup: ({ group }: ChangeGroupProps) => import('react').JSX.Element;
+export default ChangeGroup;

package/dist/modules/History/components/ChangeGroup/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ChangeGroup } from './ChangeGroup';
+export * from './ChangeGroup';
+export default ChangeGroup;

package/dist/modules/History/components/ChangeLine/ChangeLine.d.ts

@@ -0,0 +1,10 @@
+import { ChangeLine as Line } from '@plitzi/sdk-shared/history';
+export type ChangeLineProps = {
+    line: Line;
+};
+/**
+ * One thing a save did. When it is about an element that is still in the space, the line is the way to it — the same
+ * way the problems list takes someone to an element.
+ */
+declare const ChangeLine: ({ line }: ChangeLineProps) => import('react').JSX.Element;
+export default ChangeLine;

package/dist/modules/History/components/ChangeLine/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ChangeLine } from './ChangeLine';
+export * from './ChangeLine';
+export default ChangeLine;

package/dist/modules/History/components/LineLabel/LineLabel.d.ts

@@ -0,0 +1,7 @@
+import { ChangeLine } from '@plitzi/sdk-shared/history';
+export type LineLabelProps = {
+    line: ChangeLine;
+};
+/** A line's icon and words: what was done is read from the icon, what it was done to from the words. */
+declare const LineLabel: ({ line }: LineLabelProps) => import('react').JSX.Element;
+export default LineLabel;

package/dist/modules/History/components/LineLabel/index.d.ts

@@ -0,0 +1,3 @@
+import { default as LineLabel } from './LineLabel';
+export * from './LineLabel';
+export default LineLabel;

package/dist/modules/History/components/SaveDetail/SaveDetail.d.ts

@@ -0,0 +1,7 @@
+import { ChangeRecord } from '../../helpers';
+export type SaveDetailProps = {
+    change: ChangeRecord;
+};
+/** One save of a row: its number and time in a narrow column, what it did beside it, and the fields each edit changed. */
+declare const SaveDetail: ({ change }: SaveDetailProps) => import('react').JSX.Element;
+export default SaveDetail;

package/dist/modules/History/components/SaveDetail/index.d.ts

@@ -0,0 +1,3 @@
+import { default as SaveDetail } from './SaveDetail';
+export * from './SaveDetail';
+export default SaveDetail;

package/dist/modules/History/components/SnapshotMarker/SnapshotMarker.d.ts

@@ -0,0 +1,7 @@
+import { TSnapshotMarker } from '@plitzi/sdk-shared';
+export type SnapshotMarkerProps = {
+    snapshot: TSnapshotMarker;
+};
+/** Where a published revision falls on the timeline: what sits below it is what it includes. */
+declare const SnapshotMarker: ({ snapshot }: SnapshotMarkerProps) => import('react').JSX.Element;
+export default SnapshotMarker;

package/dist/modules/History/components/SnapshotMarker/index.d.ts

@@ -0,0 +1,3 @@
+import { default as SnapshotMarker } from './SnapshotMarker';
+export * from './SnapshotMarker';
+export default SnapshotMarker;

package/dist/modules/History/helpers.d.ts

@@ -0,0 +1,63 @@
+import { ChangeEntry, ChangeKind, ChangeOrigin, TSnapshotMarker, TSpaceChanges } from '@plitzi/sdk-shared';
+import { ChangeAction } from '@plitzi/sdk-shared/history';
+export type ChangeRecord = TSpaceChanges['changes'][number];
+/** Saves close enough together to read as one piece of work. A guess to revisit against real sessions (RFC 0003). */
+export declare const GROUP_WINDOW_MS = 60000;
+/** Consecutive saves by the same author from the same place: one request, or a burst of editing. */
+export type ChangeGroup = {
+    key: string;
+    changes: ChangeRecord[];
+};
+/**
+ * The timeline as a person reads it: a builder save per keystroke is noise, so consecutive saves by the same author from
+ * the same place are one row when they came from one request, or followed each other within {@link GROUP_WINDOW_MS}.
+ * `changes` arrives newest first and stays that way.
+ */
+export declare const groupChanges: (changes: ChangeRecord[]) => ChangeGroup[];
+export type TimelineRow = {
+    type: 'group';
+    group: ChangeGroup;
+} | {
+    type: 'snapshot';
+    snapshot: TSnapshotMarker;
+};
+/**
+ * Each published revision drawn right above the last change it includes — so what sits below a marker is in that
+ * revision, and what sits above is not. A revision older than everything loaded waits for the page that reaches it,
+ * unless the timeline is over.
+ */
+export declare const placeSnapshots: (groups: ChangeGroup[], snapshots: TSnapshotMarker[], complete: boolean) => TimelineRow[];
+/** A value as one short line: long ones are cut, since the diff is for spotting a change, not for reading a document. */
+export declare const formatValue: (value: unknown) => string;
+export declare const ORIGIN_LABEL: Record<ChangeOrigin, string>;
+export declare const ORIGIN_TONE: Record<ChangeOrigin, string>;
+/** Each action in its own colour and shape, so a folded row is scanned by its icons before its words. */
+export declare const ACTION_TONE: Record<ChangeAction, string>;
+export declare const ACTION_ICON: Record<ChangeAction, string>;
+export declare const MUTED = "text-zinc-500 dark:text-zinc-400";
+/** When, in the reader's own time zone: this is a person looking back at their day, not a log line. */
+export declare const formatTime: (at: number) => string;
+/** Just the time of day, for a save listed under a row that already says the date. */
+export declare const formatClock: (at: number) => string;
+/** Who, as a timeline says it: the person, or the kind of writer when no person was behind it. */
+export declare const authorLabel: (change: ChangeRecord) => string;
+export declare const ORIGIN_FILTERS: ('' | ChangeOrigin)[];
+/** A choice of the "made by" filter: an origin, or no filter at all. */
+export declare const originFilterLabel: (origin: "" | ChangeOrigin) => string;
+export declare const KIND_LABEL: Record<ChangeKind, string>;
+/** What a row of saves did, each thing on its own line and said once — ten keystrokes in one text are one line. */
+export declare const groupLines: (group: ChangeGroup) => import('@plitzi/sdk-shared').ChangeLine[];
+/** How many lines a folded row shows before it says how many more there are. */
+export declare const FOLDED_LINES = 5;
+/** What the detail of an entry shows: the fields that changed, less the tree. */
+export declare const detailOf: (entry: ChangeEntry) => import('@plitzi/sdk-shared').FieldChange[];
+/**
+ * The entries a save's detail lists: what was edited in more than its place in the tree. An add, a removal or a move is
+ * already its line, and the line is the link to the element.
+ */
+export declare const detailedEntries: (entries: ChangeEntry[]) => ChangeEntry[];
+/** A published revision, as its marker names it, and how far into the timeline it reaches. */
+export declare const snapshotLabel: ({ revision, environment, description, upToSeq }: TSnapshotMarker) => string;
+/** The changes a row covers, by number: `#50`, or `#48–50` for several saves. */
+export declare const groupRange: (group: ChangeGroup) => string;
+export declare const rowKey: (row: TimelineRow) => string;

package/dist/modules/History/hooks/useSpaceChanges.d.ts

@@ -0,0 +1,22 @@
+import { ChangeOrigin } from '@plitzi/sdk-shared';
+export type ChangeFilters = {
+    origin?: ChangeOrigin;
+    entityId?: string;
+    since?: number;
+};
+/**
+ * The space's change history, a page at a time, newest first.
+ *
+ * Read again each time the save queue drains, like the problems list: the server records a change when it saves, so
+ * that is when there is something new to show — and every loaded page is revalidated, since a filter can move rows.
+ */
+declare const useSpaceChanges: (filters: ChangeFilters) => {
+    changes: Omit<import('@plitzi/sdk-shared').SpaceChange, "environment" | "spaceId">[];
+    snapshots: import('@plitzi/sdk-shared').TSnapshotMarker[];
+    complete: boolean;
+    loading: boolean;
+    error: Error | undefined;
+    loadMore: () => undefined;
+    refresh: () => undefined;
+};
+export default useSpaceChanges;

package/dist/modules/History/index.d.ts

@@ -0,0 +1,3 @@
+import { default as History } from './History';
+export * from './History';
+export default History;

package/dist/modules/Interactions/components/Workflow/WorkflowNode/NodeWhileRunning.d.ts

@@ -0,0 +1,15 @@
+import { WhileRunning } from '@plitzi/sdk-shared';
+export type NodeWhileRunningProps = {
+    whileRunning?: WhileRunning;
+    onChange?: (data: {
+        whileRunning: WhileRunning | undefined;
+    }) => void;
+};
+/**
+ * What the trigger does when it fires again while its flow is still running — shown on the trigger alone.
+ *
+ * `skip` is written as nothing: it is what a flow does without the setting, and a document that spells out a default
+ * is one that reads as a decision somebody made.
+ */
+declare const NodeWhileRunning: ({ whileRunning, onChange }: NodeWhileRunningProps) => import('react').JSX.Element;
+export default NodeWhileRunning;

package/dist/modules/Interactions/components/Workflow/WorkflowNode/WorkflowNode.d.ts

@@ -1,5 +1,5 @@
 import { RuleGroup } from '@plitzi/plitzi-ui/QueryBuilder';
-import { InteractionCallbackParamValues, InteractionCallbackType } from '@plitzi/sdk-shared';
+import { InteractionCallbackParamValues, InteractionCallbackType, WhileRunning } from '@plitzi/sdk-shared';
 export type WorkflowNodeProps = {
     id?: string;
     title?: string;
@@ -13,10 +13,11 @@ export type WorkflowNodeProps = {
     triggerId?: string;
     params?: InteractionCallbackParamValues;
     when?: RuleGroup;
+    whileRunning?: WhileRunning;
     preview?: Record<string, unknown>;
     isOpened?: boolean;
     onOpened?: (id: string, isOpened: boolean) => void;
     onRemove?: (id: string) => void;
 };
-declare const _default: import('react').MemoExoticComponent<({ id, title, type, canDelete, action, elementId, enabled, beforeNode, afterNode, triggerId, params, when, preview, isOpened, onOpened, onRemove }: WorkflowNodeProps) => import('react').JSX.Element>;
+declare const _default: import('react').MemoExoticComponent<({ id, title, type, canDelete, action, elementId, enabled, beforeNode, afterNode, triggerId, params, when, whileRunning, preview, isOpened, onOpened, onRemove }: WorkflowNodeProps) => import('react').JSX.Element>;
 export default _default;

package/dist/modules/Interactions/components/Workflow/helpers/whileRunning.d.ts

@@ -0,0 +1,8 @@
+import { Option, OptionGroup } from '@plitzi/plitzi-ui/Select2';
+import { WhileRunning } from '@plitzi/sdk-shared';
+/** The three answers to "fired again while this flow runs", as the trigger's panel offers them. */
+export declare const WHILE_RUNNING_OPTIONS: (Exclude<Option, OptionGroup> & {
+    value: WhileRunning;
+})[];
+/** What a choice is stored as: the mode, or nothing for `skip` — the default, which a document need not spell out. */
+export declare const storedMode: (value: string | undefined) => WhileRunning | undefined;

package/dist/modules/Queue/QueueContext.d.ts

@@ -10,13 +10,7 @@ export type QueueItem<TState = any, TDispatchAction = any> = {
     state: TState;
     dispatch: ActionDispatch<[action: TDispatchAction]>;
 };
-export type QueuePriority = 'normal' | 'urgent' | 'all';
 export type QueueContextValue = {
-    queueManager: {
-        count: (priority?: QueuePriority) => number;
-        enqueue: (items?: QueueItem | QueueItem[], priority?: QueuePriority) => void;
-        getIsProcessing: () => boolean;
-    };
     enqueueMiddleware: ReducerMiddlewareCallback<Schema | Style | Record<string, Segment>, [
         action: StyleReducerActions | SchemaReducerActions | SegmentsReducerActions
     ]>;

package/dist/modules/Queue/helpers.d.ts

@@ -0,0 +1,14 @@
+/** What one queued write answered: nothing when there was nothing to send, else what the network layer reported. */
+export type QueueOutcome = {
+    success: boolean;
+    error?: string | Error;
+} | null;
+/** A write the server did not store. Nothing sent is not a failure — there was nothing to store. */
+export declare const writeFailed: (outcome: QueueOutcome) => boolean;
+/**
+ * Whether sending the same write again could change the answer.
+ *
+ * Only when the server never answered: a refusal it did answer — the change would break the space, the element is not
+ * there — is its reading of that very change, and it reads it the same way every time.
+ */
+export declare const worthRetrying: (outcome: QueueOutcome) => boolean;

package/dist/modules/Queue/hooks/useQueueManager.d.ts

@@ -1,4 +1,4 @@
-import { QueueItem, QueuePriority } from '../QueueContext';
+import { QueueItem } from '../QueueContext';
 import { BuilderMutationsMap, BuilderQueriesMap } from '@plitzi/sdk-shared';
 import { NetworkContextValue } from '@plitzi/sdk-shared/network/NetworkContext';
 export type UseQueueManagerProps = {
@@ -9,11 +9,7 @@ export type UseQueueManagerProps = {
     disabled?: boolean;
 };
 declare const useQueueManager: ({ delay, mutate, maxRetries, retryTimeout, disabled }: UseQueueManagerProps) => {
-    queueManager: {
-        count: (priority?: QueuePriority) => number;
-        enqueue: (items?: QueueItem | QueueItem[], priority?: QueuePriority) => void;
-        getIsProcessing: () => boolean;
-    };
+    enqueue: (item: QueueItem) => void;
     processing: boolean;
 };
 export default useQueueManager;

package/dist/modules/Queue/hooks/useQueueManager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/Resources/components/Resource/components/PluginInUse/PluginInUse.d.ts

@@ -0,0 +1,7 @@
+import { RootElements } from '@plitzi/sdk-schema/helpers/elementTree';
+export type PluginInUseProps = {
+    usage: RootElements[];
+};
+/** What removing a plugin leaves behind: the pages whose elements of it will render as not found. */
+declare const PluginInUse: ({ usage }: PluginInUseProps) => import('react').JSX.Element | null;
+export default PluginInUse;

package/dist/modules/Resources/components/Resource/components/PluginInUse/index.d.ts

@@ -0,0 +1,3 @@
+import { default as PluginInUse } from './PluginInUse';
+export * from './PluginInUse';
+export default PluginInUse;

package/dist/modules/Resources/components/Resource/subTypes/ResourceMedia/ResourceMedia.d.ts

@@ -0,0 +1,15 @@
+import { MouseEvent } from 'react';
+export type ResourceMediaProps = {
+    className?: string;
+    id: string;
+    type: 'image' | 'video';
+    src: string;
+    title?: string;
+    removing?: boolean;
+    directoryName?: string;
+    isLoading?: boolean;
+    onClick?: () => void;
+    onRemove?: (e: MouseEvent) => void;
+};
+declare const ResourceMedia: ({ className, id, type, title, src, removing, directoryName, isLoading, onClick, onRemove }: ResourceMediaProps) => import('react').JSX.Element;
+export default ResourceMedia;

package/dist/modules/Resources/components/Resource/subTypes/ResourceMedia/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ResourceMedia } from './ResourceMedia';
+export * from './ResourceMedia';
+export default ResourceMedia;

package/dist/modules/Resources/components/ResourceContent/components/ContentPlugin/helpers.d.ts

@@ -0,0 +1,2 @@
+/** A byte count the way a person reads one: `1.5 MB`. */
+export declare const formatBytes: (bytes: number, decimals?: number) => string;