@plitzi/plitzi-builder 0.32.25 → 0.33.1

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # @plitzi/plitzi-builder
 
+## 0.33.1
+
+### Patch Changes
+
+- v0.33.1
+- Updated dependencies
+  - @plitzi/plitzi-sdk@0.33.1
+  - @plitzi/sdk-auth@0.33.1
+  - @plitzi/sdk-dev-tools@0.33.1
+  - @plitzi/sdk-elements@0.33.1
+  - @plitzi/sdk-event-bridge@0.33.1
+  - @plitzi/sdk-interactions@0.33.1
+  - @plitzi/sdk-navigation@0.33.1
+  - @plitzi/sdk-plugins@0.33.1
+  - @plitzi/sdk-schema@0.33.1
+  - @plitzi/sdk-shared@0.33.1
+  - @plitzi/sdk-style@0.33.1
+  - @plitzi/sdk-variables@0.33.1
+
+## 0.33.0
+
+### Minor Changes
+
+- v0.33.0
+
+### Patch Changes
+
+- Updated dependencies
+  - @plitzi/plitzi-sdk@0.33.0
+  - @plitzi/sdk-auth@0.33.0
+  - @plitzi/sdk-dev-tools@0.33.0
+  - @plitzi/sdk-elements@0.33.0
+  - @plitzi/sdk-event-bridge@0.33.0
+  - @plitzi/sdk-interactions@0.33.0
+  - @plitzi/sdk-navigation@0.33.0
+  - @plitzi/sdk-plugins@0.33.0
+  - @plitzi/sdk-schema@0.33.0
+  - @plitzi/sdk-shared@0.33.0
+  - @plitzi/sdk-style@0.33.0
+  - @plitzi/sdk-variables@0.33.0
+
 ## 0.32.25
 
 ### Patch Changes

package/dist/index.d.ts

@@ -9,6 +9,7 @@ import { default as ReplicaProvider } from '@plitzi/sdk-elements/Element/Replica
 import { default as RootElement } from '@plitzi/sdk-elements/Element/RootElement';
 import { default as ComponentContext } from '@plitzi/sdk-shared/elements/ComponentContext';
 import { default as usePlitziServiceContext, PlitziServiceProvider } from '@plitzi/sdk-shared/hooks/usePlitziServiceContext';
+import { useBuilderStore } from '@plitzi/sdk-shared/store';
 import { AppProps } from './App';
 import { ComponentPlugin, RenderMode, Server } from '@plitzi/sdk-shared';
 import { ReactNode } from 'react';
@@ -33,5 +34,5 @@ declare const PlitziBuilder: {
     Plugin: (_props: import('./modules/Builder/BuilderPlugin').BuilderPluginProps) => undefined;
 };
 export declare const version: string;
-export { ComponentProvider, ComponentContext, usePlitziServiceContext, PlitziServiceProvider, RootElement, withElement, JsxManager, PluginManager, PluginRemote, ReplicaProvider, useElement, useRscData };
+export { useBuilderStore, ComponentProvider, ComponentContext, usePlitziServiceContext, PlitziServiceProvider, RootElement, withElement, JsxManager, PluginManager, PluginRemote, ReplicaProvider, useElement, useRscData };
 export default PlitziBuilder;

package/dist/index.html

@@ -57,10 +57,11 @@
         'plitzi',
         {
           webKey:
-            'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJkYXRhIjp7InNwYWNlSWQiOjF9LCJpc3MiOiJodHRwczovL3NlcnZlci5wbGl0emkubG9jYWwiLCJhdWQiOlsiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9zc3IucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9zZXJ2ZXIucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcGkucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9tY3AucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDAiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMSIsImh0dHBzOi8vd2Vic2l0ZS5wbGl0emkuYXBwIl0sInZlcnNpb24iOjEsImV4cCI6MTc4NzUxNzU3OSwiaWF0IjoxNzg0ODg3NTgzLCJuYmYiOjE3ODQ4ODc1ODN9.p5IEtdMhZrpampKtiWVuAUI6keMAAqtXmpdgL10A-6k',
+            'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxIiwib3JpZ2lucyI6WyJodHRwczovL3dlYnNpdGUucGxpdHppLmFwcCIsImh0dHBzOi8vcGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDAiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMSIsImh0dHBzOi8vc3NyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc2VydmVyLnBsaXR6aS5sb2NhbCIsImh0dHA6Ly9sb2NhbGhvc3Q6MzAwMCIsImh0dHA6Ly9sb2NhbGhvc3Q6ODA4MCIsImh0dHA6Ly8xMjcuMC4wLjE6ODA4MCJdLCJpc3MiOiJodHRwczovL3NlcnZlci5wbGl0emkubG9jYWwiLCJhdWQiOlsiaHR0cHM6Ly9wbGl0emkubG9jYWwiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWwiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMCIsImh0dHBzOi8vYXBwLnBsaXR6aS5sb2NhbDozMDAxIiwiaHR0cHM6Ly9hcGkucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9zc3IucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9zZXJ2ZXIucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9tY3AucGxpdHppLmxvY2FsIl0sInNjb3BlIjoic3BhY2U6cmVuZGVyIiwiaWF0IjoxNzg2NjU5NTg5LCJqdGkiOiJjMjRhZjMwN2Q1YTgzZmNjIiwibmJmIjoxNzg2NjU5NTg5fQ.q3-yIi5TmY8SLghX5q3jpN2qqsGJbDIF9dcVJvfLbfY',
+          // 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.eyJzdWIiOiIxIiwiaXNzIjoiaHR0cHM6Ly9zZXJ2ZXIucGxpdHppLmxvY2FsIiwiYXVkIjpbImh0dHBzOi8vcGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDAiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMSIsImh0dHBzOi8vYXBpLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc3NyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc2VydmVyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vbWNwLnBsaXR6aS5sb2NhbCJdLCJzY29wZSI6InVzZXIiLCJleHAiOjE3ODY3NDU5OTYsImlhdCI6MTc4NjY1OTU5NiwianRpIjoiNzYzOWUxNTAwN2RkMjE1OCIsIm5iZiI6MTc4NjY1OTU5Nn0.z4MIFGgjwsULzmWQx-ICM-R-GxovVYz8An4u2Vfcfms',
           environment: 'main',
-          revision: 0,
-          renderMode: 'raw',
           server: {
             basePath: '',
             // Dashboard

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

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

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

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

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

@@ -10,8 +10,7 @@ export type AppProviderProps = {
     server: Server;
     includeSubscriptions: boolean;
     includeRealTime: boolean;
-    previewMode: boolean;
     debugMode?: boolean;
 };
-declare const AppProvider: ({ children, instanceId, webKey, webId, environment, userKey, server, includeSubscriptions, includeRealTime, previewMode, debugMode }: AppProviderProps) => import("react").JSX.Element;
+declare const AppProvider: ({ children, instanceId, webKey, webId, environment, userKey, server, includeSubscriptions, includeRealTime, debugMode }: AppProviderProps) => import("react").JSX.Element;
 export default AppProvider;

package/dist/modules/Builder/components/BuilderElementTools/ElementSettings.d.ts

@@ -1,8 +1,12 @@
+import { ElementRuntime } from '@plitzi/sdk-shared';
 export type ElementSettingsProps = {
     id?: string;
     type?: string;
     attributes?: Record<string, unknown>;
+    /** Where the element resolves its data. Lives on the definition, not the attributes, but a provider's settings
+     *  panel has to show and change it — everything else about that panel depends on which side is fetching. */
+    runtime?: ElementRuntime;
     handleChange?: (key: string, value: string | boolean | number | object, isDefinition?: boolean) => void;
 };
-declare const ElementSettings: ({ id, type, attributes, handleChange }: ElementSettingsProps) => import("react").JSX.Element;
+declare const ElementSettings: ({ id, type, attributes, runtime, handleChange }: ElementSettingsProps) => import("react").JSX.Element;
 export default ElementSettings;

package/dist/modules/Collaboration/CollaborationHelper.d.ts

@@ -0,0 +1,53 @@
+import { SubscriptionCollaboratorElementState } from '@plitzi/sdk-shared';
+/**
+ * The coordinate protocol between collaborators, both ends of it in one place.
+ *
+ * A pointer cannot travel as a coordinate. Peers differ in window size, zoom level and scroll offset, and the
+ * canvas lays the page out at whatever width it is given — a zoomed builder lays it out narrower — so the same
+ * pixel, and the same fraction of the viewport, is a different place on each screen. It travels anchored to an
+ * element instead: a ratio inside the box of the element nearest the pointer, plus a pixel delta when the
+ * pointer is outside that box. The receiver resolves the anchor against its own DOM, in the same canvas space
+ * the overlays use, so a collaborator's cursor and their selection box can never disagree.
+ */
+export type CollaboratorCursorAnchor = {
+    anchorId: string;
+    x: number;
+    y: number;
+    dx: number;
+    dy: number;
+};
+export type CollaboratorCursorPosition = {
+    x: number;
+    y: number;
+};
+export type CollaboratorCursorContext = {
+    rootId: string;
+    containerDOM?: HTMLElement | null;
+    iframeDOM?: HTMLIFrameElement | null;
+    zoom?: number;
+};
+/** The element pair both ends agree on: the sender picks anchors with it, the receiver looks them up with it. */
+declare const collaboratorAnchorSelector: (rootId: string) => string;
+/**
+ * Sender: turns a pointer event into the anchored position to broadcast. Returns the chosen anchor too, so the
+ * caller can feed it back as `previous` and keep the choice stable between frames.
+ */
+declare const readCursorAnchor: (event: PointerEvent, { selector, previous, scale }: {
+    selector: string;
+    previous?: HTMLElement | null;
+    scale?: number;
+}) => {
+    anchorDOM: HTMLElement;
+    position: CollaboratorCursorAnchor;
+} | undefined;
+/**
+ * Receiver: places an anchored position on this canvas, in unzoomed content pixels — the space `processContainer`
+ * gives the overlays.
+ */
+declare const resolveCursorPosition: ({ anchorId, x, y, dx, dy }: Partial<CollaboratorCursorAnchor> & CollaboratorCursorPosition, { rootId, containerDOM, iframeDOM, zoom }: CollaboratorCursorContext) => CollaboratorCursorPosition | undefined;
+/** What the collaborator had hovered/selected when the snapshot was taken, kept only for the root being edited. */
+declare const resolveElementState: (elementState: SubscriptionCollaboratorElementState | undefined, rootId: string) => {
+    hovered: string | undefined;
+    selected: string | undefined;
+};
+export { collaboratorAnchorSelector, readCursorAnchor, resolveCursorPosition, resolveElementState };

package/dist/modules/Collaboration/components/CollaboratorArea/CollaboratorArea.d.ts

@@ -0,0 +1,16 @@
+import { DisplayMode, SubscriptionCollaboratorElementState } from '@plitzi/sdk-shared';
+import { RefObject } from 'react';
+export type CollaboratorAreaProps = {
+    baseElementId?: string;
+    color?: string;
+    debugMode?: boolean;
+    elementState?: SubscriptionCollaboratorElementState;
+    instanceId: string;
+    title?: string;
+    refIframe: RefObject<HTMLIFrameElement | null>;
+    trackingContainerRef: RefObject<HTMLDivElement | null>;
+    zoom?: number;
+    displayMode?: DisplayMode;
+};
+declare const _default: import('react').MemoExoticComponent<({ baseElementId, color, debugMode, elementState, instanceId, title, refIframe, trackingContainerRef, zoom, displayMode }: CollaboratorAreaProps) => import("react").JSX.Element>;
+export default _default;

package/dist/modules/Collaboration/components/CollaboratorArea/CollaboratorCursor.d.ts

@@ -0,0 +1,9 @@
+import { RefObject } from 'react';
+export type CollaboratorCursorProps = {
+    ref: RefObject<HTMLDivElement | null>;
+    title?: string;
+    color?: string;
+    zoom?: number;
+};
+declare const CollaboratorCursor: ({ ref, title, color, zoom }: CollaboratorCursorProps) => import("react").JSX.Element;
+export default CollaboratorCursor;

package/dist/modules/Collaboration/components/CollaboratorArea/index.d.ts

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

package/dist/modules/Collaboration/components/CollaboratorAvatar/CollaboratorAvatar.d.ts

@@ -0,0 +1,10 @@
+import { RefObject } from 'react';
+export type CollaboratorAvatarProps = {
+    ref?: RefObject<HTMLDivElement | null>;
+    color?: string;
+    firstName: string;
+    surName: string;
+};
+/** The collaborator's initials in their presence color, as shown in the app header. */
+declare const CollaboratorAvatar: ({ ref, color, firstName, surName }: CollaboratorAvatarProps) => import("react").JSX.Element;
+export default CollaboratorAvatar;

package/dist/modules/Collaboration/components/CollaboratorAvatar/index.d.ts

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

package/dist/modules/Collaboration/hooks/useCollaboratorCursor.d.ts

@@ -0,0 +1,22 @@
+export type UseCollaboratorCursorProps = {
+    rootId: string;
+    zoom?: number;
+    enabled?: boolean;
+};
+/**
+ * Broadcasts this user's pointer over a canvas. Returns the props to spread on the canvas element; the whole
+ * lifecycle (enter, sampled moves, leave) lives here, so a caller never has to remember that a cursor left
+ * behind on a peer's screen stays there forever.
+ */
+declare const useCollaboratorCursor: ({ rootId, zoom, enabled }: UseCollaboratorCursorProps) => {
+    bind: () => {
+        onPointerEnter?: undefined;
+        onPointerLeave?: undefined;
+        onPointerMove?: undefined;
+    } | {
+        onPointerEnter(): void;
+        onPointerLeave(): void;
+        onPointerMove(e: React.PointerEvent): void;
+    };
+};
+export default useCollaboratorCursor;

package/dist/modules/Collaboration/hooks/useCollaboratorElements.d.ts

@@ -0,0 +1,8 @@
+export type UseCollaboratorElementsProps = {
+    rootId: string;
+    elementHovered?: string;
+    elementSelected?: string;
+};
+/** Broadcasts what this user has hovered/selected, which is what draws their overlays on everyone else's canvas. */
+declare const useCollaboratorElements: ({ rootId, elementHovered, elementSelected }: UseCollaboratorElementsProps) => void;
+export default useCollaboratorElements;

package/dist/modules/Collaboration/hooks/useCollaborators.d.ts

@@ -0,0 +1,17 @@
+import { SubscriptionCollaborator } from '@plitzi/sdk-shared';
+import { BuilderSubscriptionsContextValue } from '../../Network/contexts/BuilderSubscriptionsContext';
+export type UseCollaboratorsProps = {
+    enabled?: boolean;
+    instanceId: string;
+    registerCallback: BuilderSubscriptionsContextValue['subscriptionsRegisterCallback'];
+    unregisterCallback: BuilderSubscriptionsContextValue['subscriptionsUnregisterCallback'];
+};
+/**
+ * Keeps `collaboration.collaborators` in sync with the connection: the INIT snapshot plus the join/leave events.
+ * It writes to the store and reads nothing back, so presence changes never re-render the transport that carries
+ * them — and every surface that wants presence reads the store instead of being handed it.
+ */
+declare const useCollaborators: ({ enabled, instanceId, registerCallback, unregisterCallback }: UseCollaboratorsProps) => {
+    resetCollaborators: (incoming: SubscriptionCollaborator[]) => void;
+};
+export default useCollaborators;

package/dist/modules/Connectors/Connectors.d.ts

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

package/dist/modules/Connectors/ConnectorsContext.d.ts

@@ -0,0 +1,13 @@
+import { ConnectorManifestDraft, SpaceConnector } from '@plitzi/sdk-shared';
+export type ConnectorsContextValue = {
+    connectors: Record<string, SpaceConnector>;
+    isLoading: boolean;
+    error: string;
+    /** True when the space has at least one deployment that can run server code, which is what resolves connectors. */
+    hasServerRendering: boolean;
+    addConnector: (name: string, manifest: ConnectorManifestDraft) => Promise<SpaceConnector | undefined>;
+    updateConnector: (identifier: string, name: string, manifest: ConnectorManifestDraft) => Promise<SpaceConnector | undefined>;
+    removeConnector: (identifier: string) => Promise<boolean>;
+};
+declare const ConnectorsContext: import('react').Context<ConnectorsContextValue>;
+export default ConnectorsContext;

package/dist/modules/Connectors/ConnectorsContextProvider.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+export type ConnectorsContextProviderProps = {
+    children: ReactNode;
+};
+/**
+ * Loads the space's connector manifests and keeps them in the builder store.
+ *
+ * They live in the store rather than in this context alone because the provider element's settings panel — which
+ * renders far from here, inside the element inspector — needs the connector list and each manifest's operators to
+ * offer a picker and typed filters. The store is editor state and is never serialized into the published schema,
+ * so putting endpoints there does not put them on a visitor's page.
+ */
+declare const ConnectorsContextProvider: ({ children }: ConnectorsContextProviderProps) => import("react").JSX.Element;
+export default ConnectorsContextProvider;

package/dist/modules/Connectors/components/ConnectorAdvancedEditor/ConnectorAdvancedEditor.d.ts

@@ -0,0 +1,14 @@
+export type ConnectorAdvancedEditorProps = {
+    value: string;
+    error?: string;
+    onChange: (value: string) => void;
+};
+/**
+ * The manifest as the server stores it.
+ *
+ * The basic editor covers the fields a CMS connector actually needs; this is here for the provider that does not fit
+ * — an extra endpoint, a hand-written operator, a field the form has no control for. Both edit the same document,
+ * so switching modes is not a conversion.
+ */
+declare const ConnectorAdvancedEditor: ({ value, error, onChange }: ConnectorAdvancedEditorProps) => import("react").JSX.Element;
+export default ConnectorAdvancedEditor;

package/dist/modules/Connectors/components/ConnectorAdvancedEditor/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './ConnectorAdvancedEditor';
+export type { ConnectorAdvancedEditorProps } from './ConnectorAdvancedEditor';

package/dist/modules/Connectors/components/ConnectorBasicEditor/ConnectorBasicEditor.d.ts

@@ -0,0 +1,7 @@
+import { ConnectorManifestDraft } from '@plitzi/sdk-shared';
+export type ConnectorBasicEditorProps = {
+    manifest: ConnectorManifestDraft;
+    onChange: (manifest: ConnectorManifestDraft) => void;
+};
+declare const ConnectorBasicEditor: ({ manifest, onChange }: ConnectorBasicEditorProps) => import("react").JSX.Element;
+export default ConnectorBasicEditor;

package/dist/modules/Connectors/components/ConnectorBasicEditor/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './ConnectorBasicEditor';
+export type { ConnectorBasicEditorProps } from './ConnectorBasicEditor';

package/dist/modules/Connectors/components/ConnectorEndpointEditor/ConnectorEndpointEditor.d.ts

@@ -0,0 +1,20 @@
+import { EndpointKind } from '../../helpers/updateManifest';
+import { ConnectorReadEndpoint, ConnectorWriteEndpoint } from '@plitzi/sdk-shared';
+export type ConnectorEndpointEditorProps = {
+    kind: EndpointKind;
+    name: string;
+    endpoint: ConnectorReadEndpoint | ConnectorWriteEndpoint;
+    onChange: (name: string, endpoint: ConnectorReadEndpoint | ConnectorWriteEndpoint) => void;
+    /** Returns false when the new name is empty or already taken, so the field can snap back. */
+    onRename: (from: string, to: string) => boolean;
+    onRemove: (name: string) => void;
+};
+/**
+ * One named request.
+ *
+ * Reads and writes share this editor because they are the same thing to an author — a method, a path, and how to
+ * read the answer — and differ only in which extra fields apply. Splitting them into two components would duplicate
+ * the path, query and header rows, which are where the templating lives.
+ */
+declare const ConnectorEndpointEditor: ({ kind, name, endpoint, onChange, onRename, onRemove }: ConnectorEndpointEditorProps) => import("react").JSX.Element;
+export default ConnectorEndpointEditor;

package/dist/modules/Connectors/components/ConnectorEndpointEditor/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './ConnectorEndpointEditor';
+export type { ConnectorEndpointEditorProps } from './ConnectorEndpointEditor';

package/dist/modules/Connectors/components/ConnectorEndpointsEditor/ConnectorEndpointsEditor.d.ts

@@ -0,0 +1,13 @@
+import { ConnectorManifestDraft } from '@plitzi/sdk-shared';
+export type ConnectorEndpointsEditorProps = {
+    manifest: ConnectorManifestDraft;
+    onChange: (manifest: ConnectorManifestDraft) => void;
+};
+/**
+ * Every request the connector can make, read and write.
+ *
+ * Both sides are lists an author adds to, because a connector talks to a REST API and an API has as many operations
+ * as it has — one read called `list` and three CRUD writes is the CMS special case, not the model.
+ */
+declare const ConnectorEndpointsEditor: ({ manifest, onChange }: ConnectorEndpointsEditorProps) => import("react").JSX.Element;
+export default ConnectorEndpointsEditor;

package/dist/modules/Connectors/components/ConnectorEndpointsEditor/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './ConnectorEndpointsEditor';
+export type { ConnectorEndpointsEditorProps } from './ConnectorEndpointsEditor';

package/dist/modules/Connectors/components/ConnectorForm/ConnectorForm.d.ts

@@ -0,0 +1,8 @@
+import { ConnectorManifestDraft, SpaceConnector } from '@plitzi/sdk-shared';
+export type ConnectorFormProps = {
+    connector?: SpaceConnector;
+    onSubmit: (name: string, manifest: ConnectorManifestDraft) => Promise<void> | void;
+    onCancel: () => void;
+};
+declare const ConnectorForm: ({ connector, onSubmit, onCancel }: ConnectorFormProps) => import("react").JSX.Element;
+export default ConnectorForm;

package/dist/modules/Connectors/components/ConnectorForm/index.d.ts

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

package/dist/modules/Connectors/components/ConnectorList/ConnectorList.d.ts

@@ -0,0 +1,9 @@
+import { SpaceConnector } from '@plitzi/sdk-shared';
+export type ConnectorListProps = {
+    connectors: SpaceConnector[];
+    onSelect: (identifier: string) => void;
+    onRemove: (identifier: string) => void;
+    onCreate: () => void;
+};
+declare const ConnectorList: ({ connectors, onSelect, onRemove, onCreate }: ConnectorListProps) => import("react").JSX.Element;
+export default ConnectorList;

package/dist/modules/Connectors/components/ConnectorList/index.d.ts

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

package/dist/modules/Connectors/components/ConnectorSection/ConnectorSection.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+export type ConnectorSectionProps = {
+    id: string;
+    title: string;
+    /** Shown on the collapsed header: what this section currently holds, in a few words. */
+    summary: string;
+    description?: string;
+    /** Marks a collapsed section whose contents were customized, so nothing hides silently. */
+    highlight?: boolean;
+    defaultOpen?: boolean;
+    children: ReactNode;
+};
+/**
+ * One collapsible block of the manifest form.
+ *
+ * A connector has more areas than anyone edits at once and a preset fills most of them correctly, so the panel
+ * opens with the ones an author actually touches and keeps the rest one click away. Each closed header carries a
+ * summary of its own value — collapsing that hid the information would only trade scrolling for clicking.
+ *
+ * The prose for each field is opt-in behind the header's `?`, because an explanation is read once and then becomes
+ * the thing standing between the author and the next field.
+ */
+declare const ConnectorSection: ({ id, title, summary, description, highlight, defaultOpen, children }: ConnectorSectionProps) => import("react").JSX.Element;
+export default ConnectorSection;

package/dist/modules/Connectors/components/ConnectorSection/ConnectorSectionContext.d.ts

@@ -0,0 +1,8 @@
+export type ConnectorSectionContextValue = {
+    /** Whether the surrounding section is currently showing its field-level prose. */
+    showHelp: boolean;
+    /** How deep this section sits. Sections read it to indent and tint themselves relative to their parent. */
+    depth: number;
+};
+declare const ConnectorSectionContext: import('react').Context<ConnectorSectionContextValue>;
+export default ConnectorSectionContext;

package/dist/modules/Connectors/components/ConnectorSection/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from './ConnectorSection';
+export { default as ConnectorSectionContext } from './ConnectorSectionContext';
+export type { ConnectorSectionProps } from './ConnectorSection';

package/dist/modules/Connectors/components/FieldGrid/FieldGrid.d.ts

@@ -0,0 +1,22 @@
+import { ReactNode } from 'react';
+export type FieldGridProps = {
+    children: ReactNode;
+    /**
+     * Fixed number of columns. Omitted, the grid fits as many as the width allows.
+     *
+     * A fixed count does not adapt, so it is for rows whose fields belong together and should stay aligned — pick it
+     * when the layout is part of the meaning, not to hand-tune a breakpoint.
+     */
+    columns?: 1 | 2 | 3 | 4;
+    className?: string;
+};
+/**
+ * Flows short fields into columns.
+ *
+ * The Connectors panel renders in the main area, not in a 350px dock, so on a wide monitor a single column of
+ * full-width inputs leaves most of the screen empty and stretches every field far past the length of what goes in
+ * it. The default `auto-fill` handles that without breakpoints: one column in a narrow panel, three in a wide one,
+ * and nothing to keep in step with the popup's resize handle.
+ */
+declare const FieldGrid: ({ children, columns, className }: FieldGridProps) => import("react").JSX.Element;
+export default FieldGrid;

package/dist/modules/Connectors/components/FieldGrid/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './FieldGrid';
+export type { FieldGridProps } from './FieldGrid';

package/dist/modules/Connectors/components/FieldHelp/FieldHelp.d.ts

@@ -0,0 +1,11 @@
+export type FieldHelpProps = {
+    children: string;
+};
+/**
+ * The explanation for one field, shown only while its section has help turned on.
+ *
+ * The same text is always on the field as a `title`, so hovering answers the question without turning anything on.
+ * This is the version for someone meeting the form for the first time.
+ */
+declare const FieldHelp: ({ children }: FieldHelpProps) => import("react").JSX.Element | null;
+export default FieldHelp;

package/dist/modules/Connectors/components/FieldHelp/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './FieldHelp';
+export type { FieldHelpProps } from './FieldHelp';

package/dist/modules/Connectors/components/TokenInput/TokenInput.d.ts

@@ -0,0 +1,19 @@
+import { ConnectorTokenScope } from '@plitzi/sdk-shared';
+export type TokenInputProps = {
+    label: string;
+    /** Hover text. The same line is available in full under the section's help toggle via `FieldHelp`. */
+    title?: string;
+    value: string;
+    placeholder?: string;
+    scope?: ConnectorTokenScope;
+    onChange: (value: string) => void;
+};
+/**
+ * A one-line field that completes the engine's template tokens.
+ *
+ * Every value in a manifest is a template, and the tokens are the part an author cannot guess — the difference
+ * between `{{offset}}` and `{{page}}` decides whether paging works at all. Ctrl+Space (or typing a prefix) lists
+ * what this position accepts, which is why these are CodeMirror fields rather than plain inputs.
+ */
+declare const TokenInput: ({ label, title, value, placeholder, scope, onChange }: TokenInputProps) => import("react").JSX.Element;
+export default TokenInput;

package/dist/modules/Connectors/components/TokenInput/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './TokenInput';
+export type { TokenInputProps } from './TokenInput';

package/dist/modules/Connectors/helpers/manifestDoc.d.ts

@@ -0,0 +1,41 @@
+import { ConnectorPagination } from '@plitzi/sdk-shared';
+export type PaginationDoc = {
+    value: ConnectorPagination;
+    label: string;
+    description: string;
+};
+/**
+ * What each paging style means in the provider's own terms.
+ *
+ * The names come from the CMS vendors, not from Plitzi, and "offset" versus "page" is the single choice most likely
+ * to be picked wrong — both look like paging, and getting it backwards returns the first window forever. The
+ * descriptions name the token each style makes available so the choice and the query template stay connected.
+ */
+export declare const paginationDocs: PaginationDoc[];
+/**
+ * One line per manifest field, in the terms of the thing being described rather than the JSON key.
+ *
+ * These are the questions an author actually has — "where do the records live in the response?" — and answering them
+ * in the panel is the difference between the basic editor being usable and being a prettier JSON editor.
+ */
+export declare const fieldDocs: {
+    readonly baseUrl: "Where the CMS lives, e.g. https://cms.example.com. Every path below is appended to it.";
+    readonly credential: "The secret this connector authenticates with. It is stored encrypted and resolved on the server; the manifest only ever names it.";
+    readonly authIn: "Whether the credential travels as a request header or as a query parameter.";
+    readonly authName: "The header or parameter name, e.g. Authorization.";
+    readonly authValue: "The value to send. Reference the secret as {{credential.token}} — never paste the token itself.";
+    readonly headers: "Extra headers sent with every request. Values accept the same tokens.";
+    readonly method: "HTTP method this endpoint expects. Reading is usually GET; a search endpoint often takes POST.";
+    readonly path: "Path appended to the base URL, with {{resource}} where the collection name goes, e.g. /api/{{resource}}.";
+    readonly listQuery: "Query parameters sent on every read. This is where paging tokens go, e.g. limit = {{limit}}.";
+    readonly writeQuery: "Query parameters sent with this write.";
+    readonly endpointHeaders: "Headers for this endpoint only, merged over the connection headers.";
+    readonly itemsPath: "Where the records array lives in the response, e.g. data. Leave empty if the response is the array.";
+    readonly totalPath: "Where the total record count lives, e.g. meta.pagination.total. Without it a pager can only offer next and previous.";
+    readonly idPath: "Where the id of each record lives, relative to the record. Defaults to id.";
+    readonly valuesPath: "Where the fields of each record live, relative to the record. Use . when the record itself holds them.";
+    readonly operators: "How this provider spells each comparison. The element picks an operator by name; this template turns it into a query parameter.";
+    readonly mediaBaseUrl: "Host to prepend to relative image and file URLs the CMS returns. Only values under keys ending in url, src or href are rewritten.";
+    readonly writeBodyPath: "Key to wrap the submitted values in, e.g. data. Leave empty to send them at the root.";
+};
+export declare const CONNECTOR_SERVER_ONLY_NOTE = "Connectors resolve on the server before the page reaches the browser. A space published without server rendering has no server to resolve them.";

package/dist/modules/Connectors/helpers/parseManifest.d.ts

@@ -0,0 +1,17 @@
+import { ConnectorManifestDraft } from '@plitzi/sdk-shared';
+export type ParseManifestResult = {
+    manifest: ConnectorManifestDraft;
+    error?: undefined;
+} | {
+    manifest?: undefined;
+    error: string;
+};
+/**
+ * Reads the advanced editor's text back into a manifest.
+ *
+ * The basic editor can only produce a well-formed document; hand-typed JSON can produce anything, so the shape is
+ * checked before it reaches code that assumes it. `endpoints.read` is the one part with no default worth guessing:
+ * a connector that cannot say how to read records is not a connector.
+ */
+export declare const parseManifest: (value: string) => ParseManifestResult;
+export default parseManifest;

package/dist/modules/Connectors/helpers/summarizeManifest.d.ts

@@ -0,0 +1,18 @@
+import { ConnectorManifestDraft, ConnectorReadEndpoint, ConnectorWriteEndpoint } from '@plitzi/sdk-shared';
+/**
+ * One short line per section, shown on its collapsed header.
+ *
+ * Collapsing is only an improvement if a closed section still answers "what is in there". Without these the panel
+ * trades a wall of fields for a wall of chevrons, and the author has to open all of them to check their own work.
+ */
+export declare const summarize: {
+    auth: (manifest: ConnectorManifestDraft) => string;
+    endpoints: (manifest: ConnectorManifestDraft) => string;
+    pagination: (manifest: ConnectorManifestDraft) => string;
+    filters: (manifest: ConnectorManifestDraft) => string;
+    media: (manifest: ConnectorManifestDraft) => string;
+};
+/** `GET /api/posts` — the request itself, which is what identifies an endpoint at a glance. */
+export declare const summarizeEndpoint: (endpoint: ConnectorReadEndpoint | ConnectorWriteEndpoint) => string;
+/** True when a read endpoint maps the response by hand, so a collapsed header can say it was customized. */
+export declare const hasResponseMapping: (endpoint: ConnectorReadEndpoint) => boolean;