@sevenfold/setto-client 0.12.1 → 0.14.0

package/dist/admin/App.d.ts

@@ -1,11 +1,16 @@
 /**
- * Drop-in admin SPA. Mount under a route like `<Route path="/setto/*" .../>`.
+ * The page at `/setto`. Mount it under a route like `<Route path="/setto/*" …>`.
  *
- * Behaviour after login:
- *  - Redirects to the site home `/`. Edit mode activates automatically there
- *    via `SettoProvider` when the user has access to `config.siteId`.
- *  - Shows the dashboard only when the user lacks access to this site, or
- *    when a panel was asked for: `/setto?deployment=…` for publish progress
- *    and history, `/setto?view=<module>` for a module's panel (forms today).
+ * What draws it lives in setto-server now, not here. The chrome bundle offers a
+ * dashboard at runtime — publish history, the forms inbox, the domain panel —
+ * and that is what fills this route, so changing any of it is one deploy of
+ * Setto rather than a rebuild of every site it has ever made.
+ *
+ * What stays behind is the door: sign in, and get back to the site to edit.
+ * That much has to work from the site's own bundle, because it is the only way
+ * in and because the bug that takes the chrome down could be mine. Everything
+ * past the door is Setto's, needs Setto to be reachable to do anything at all,
+ * and is better absent than drawn from a copy that has been quietly rotting in
+ * a pinned version since the day the site was built.
  */
 export declare function SettoAdminApp(): import("react/jsx-runtime").JSX.Element;

package/dist/chrome.d.ts

@@ -24,12 +24,25 @@ export interface SettoChromeHandshake {
     /**
      * The same, for the page at `/setto`.
      *
-     * A second slot because the dashboard is not an overlay: it belongs in the
-     * host's own route, where the customer navigated to it. Registering nothing
-     * leaves the bundled dashboard in place, which is what keeps a chrome that
-     * fails to load from taking the admin down with it.
+     * @deprecated Use `mountSlot('admin', …)`. Kept because a chrome bundle
+     * older than this file may still call it, and the whole point of this file
+     * is that it never has to change again.
      */
     mountAdmin: (Component: React.ComponentType) => void;
+    /**
+     * Offer a component for a named place in the host: `admin` for the page at
+     * `/setto`, `toolbar` for the editor's floating menu.
+     *
+     * Named rather than one method per surface, because every new method here
+     * costs a re-pin of the whole fleet — the exact price this file exists to
+     * avoid paying. A new surface is now a string the host already understands,
+     * or one it will simply ignore.
+     *
+     * Registering nothing leaves the host's own version in place. That is what
+     * keeps a chrome bundle that fails to load, or throws while rendering, from
+     * taking the editor down with it.
+     */
+    mountSlot: (name: string, Component: React.ComponentType) => void;
     /**
      * The host's own `useSetto`, callable from the chrome.
      *
@@ -70,8 +83,11 @@ declare global {
     }
 }
 /**
- * What the host should render at `/setto`, or null while the chrome has not
- * offered anything. Callers fall back to their bundled dashboard.
+ * What the host should render in a named place, or null while the chrome has
+ * offered nothing — including after it offered something that threw. Callers
+ * render their own version when this is null; every one of them must have one.
  */
+export declare function useSettoChromeSlot(name: string): React.ComponentType | null;
+/** @deprecated Use `useSettoChromeSlot('admin')`. */
 export declare function useSettoAdminChrome(): React.ComponentType | null;
 export declare function SettoChrome(): import("react/jsx-runtime").JSX.Element | null;

package/dist/edit-mode/toolbar-fallback.d.ts

@@ -0,0 +1 @@
+export declare function ToolbarUnavailable(): import("react/jsx-runtime").JSX.Element | null;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { SettoProvider, useSetto } from './provider';
 export { GuestEditProvider, useGuestEdit } from './guest-edit';
 export { SettoPreviewBar, isPreviewHost, previewBarState } from './preview-bar';
-export { SettoChrome } from './chrome';
+export { SettoChrome, useSettoChromeSlot } from './chrome';
 export type { SettoChromeHandshake } from './chrome';
 export { T } from './T';
 export { SettoSection } from './SettoSection';
@@ -35,4 +35,8 @@ export { extractContentKeys, type ContentKeyRequirements, } from './block-tree/e
 export { BLOCK_REGISTRY, BLOCK_TYPES, nodeChildren } from './block-tree/registry';
 export type { BlockTypeMeta } from './block-tree/registry';
 export { SETTO_BASE, siteHomeUrl, isAdminRoute, isAdminDeploymentView, adminViewUrl, currentAdminView, isAdminPanelView, adminRedirectUrl, CHECKOUT_INTENT, checkoutIntentUrl, wantsCheckout, withoutCheckoutIntent, } from './lib/urls';
-export { IN_PROGRESS_STATUSES, isDeploymentInProgress, isDeploymentStale, STALE_PENDING_MS, STALE_BUILDING_MS, fetchInProgressDeploymentId, waitForDeploymentByCommit, useDeploymentStatus, PublishProgressBar, } from './edit-mode/deployment-status';
+export { SettoMark } from './edit-mode/setto-mark';
+export { FAB_SIZE, FAB_INSET } from './edit-mode/constants';
+export { EMPTY_I18N_STORE_SNAPSHOT } from './lib/i18n-store';
+export type { I18nStoreSnapshot } from './lib/i18n-store';
+export { IN_PROGRESS_STATUSES, isDeploymentInProgress, isDeploymentStale, STALE_PENDING_MS, STALE_BUILDING_MS, fetchInProgressDeploymentId, waitForDeploymentByCommit, useDeploymentStatus, PublishProgressBar, PublishProgressSteps, } from './edit-mode/deployment-status';

package/dist/lib/i18n-store.d.ts

@@ -56,6 +56,16 @@ export declare class I18nStore {
         namespace?: string;
     });
     snapshot(): I18nStoreSnapshot;
+    /**
+     * Put a locale file into i18next as the published baseline.
+     *
+     * Same reason as `languages`: the editor chrome cannot reach the live
+     * i18next instance from its own bundle, and this store already holds it.
+     * Deep and overwriting, which is what seeding a baseline means — the file
+     * from the repository is the truth, and any draft on top of it lives here,
+     * not in i18next.
+     */
+    addBaselineBundle(lng: string, resources: Record<string, unknown>): void;
     subscribe(listener: Listener): () => void;
     /**
      * Returns the current rendered value for a key in a given language,
@@ -111,7 +121,20 @@ export declare class I18nStore {
     serialiseBundles(): Record<string, unknown>;
     /** Runs `fn` and notifies consumers once, however many edits it makes. */
     batch(fn: () => void): void;
-    private languages;
+    /**
+     * Every language this site has content for, in i18next's own order.
+     *
+     * Public because the editor chrome needs it and cannot get it the usual way:
+     * that code runs in a second bundle whose `react-i18next` is a different
+     * module instance from the host's, so its `useTranslation` finds no
+     * initialised i18next and reports no languages at all. This store is the
+     * host's own object, handed across by reference, and it already holds the
+     * live instance.
+     *
+     * Deduplicated, because i18next appends its fallback chain and every caller
+     * was doing that itself.
+     */
+    languages(fallback: string): string[];
     private valueOrUndefined;
     private setOrDelete;
     /** Every string key under `prefix`, nested to any depth. */

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

@@ -6,6 +6,8 @@ import type { SettoModule } from '../module';
  * setting somebody returns to — when they finally buy the name, when they move
  * registrar, when a record gets deleted by accident — and the conversation
  * that built the site is not somewhere anybody goes back to.
+ *
+ * Only the tab is here. The panel behind it is served from setto-server, which
+ * is also where the DNS instructions are worked out.
  */
 export declare const domainModule: SettoModule;
-export { DomainView } from './DomainView';

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

@@ -1,8 +1,8 @@
 import type { SettoModule } from '../module';
 /**
- * The forms module: a form primitive the site renders, an inbox in the
- * dashboard, and the api segment between them. Server side lives in
- * setto-server `src/modules/forms`.
+ * The forms module: a form primitive the site renders, and the api segment
+ * behind it. Server side lives in setto-server `src/modules/forms`, and so
+ * does the inbox the customer reads submissions in.
  */
 export declare const formsModule: SettoModule;
 export { SettoForm } from './SettoForm';

package/dist/modules/index.d.ts

@@ -1,5 +1,5 @@
 import type { SettoModule } from './module';
 export type { SettoModule } from './module';
-/** Every module the dashboard shows, in tab order. */
+/** Every module the dashboard shows, in tab order. Setto draws the tabs. */
 export declare const SETTO_MODULES: readonly SettoModule[];
 export declare function findModule(id: string | null): SettoModule | undefined;

package/dist/modules/module.d.ts

@@ -1,30 +1,26 @@
-import type { ComponentType } from 'react';
 /**
  * What a Setto module is, from the client's side.
  *
  * A module is a capability a site gets by using the library — forms today;
  * bookings, newsletters, reviews later. Each one is a directory under
- * `src/modules/<id>` that owns its three faces:
+ * `src/modules/<id>` that owns the two faces the customer's own bundle has to
+ * carry:
  *
  *   - a primitive the site renders (`SettoForm`), with edit chrome for the
  *     owner and content that lives in the locale so it publishes with the
  *     rest of the site;
- *   - a panel in the dashboard at `/setto?view=<id>` (`AdminView`), reached
- *     from the editor toolbar's settings item;
  *   - an api segment (`createFormsApi`) that `createApi` mounts under its id,
  *     against routes setto-server keeps under `src/modules/<id>`.
  *
- * Registering the module in `src/modules/index.ts` is what puts its tab in
- * the dashboard. The primitive and the types are exported from the package
- * root like everything else.
+ * The third face — the panel at `/setto?view=<id>` — is not here. It lives in
+ * setto-server under `chrome/src/admin/modules`, and arrives at runtime, so a
+ * new module's panel ships in a deploy instead of a rebuild of every site.
+ * What this list is still for is the editor toolbar, which links to those
+ * panels from the customer's page and needs their ids and labels to do it.
  */
 export interface SettoModule {
     /** Stable id — also the dashboard view name and the api segment name. */
     id: string;
     /** Tab label in the dashboard, in Norwegian. */
     label: string;
-    /** The dashboard panel for the current site. */
-    AdminView: ComponentType<{
-        siteId: string;
-    }>;
 }