@plitzi/plitzi-sdk 0.37.8 → 0.37.10

package/dist/App.d.ts

@@ -43,8 +43,21 @@ export type AppProps = {
     /** The theme the host already settled — from the cookie a server read before it rendered the document. */
     theme?: Theme;
     state?: Record<string, unknown>;
+    /**
+     * The feature flags this embedding decides, by name: `{ newCheckout: true }`. Above whatever the space and the server
+     * rendering it say, below a tester with the dev tools. Only for flags the space declares — anything else is ignored,
+     * with a warning in the console.
+     */
+    flags?: Record<string, boolean>;
+    /** Set by the server that rendered this page: the flags its deployment decides (`createServer({ flags })`). */
+    serverFlags?: Record<string, boolean>;
+    /**
+     * Set by the server that rendered this page for somebody allowed to debug it: the flags a tester forced, read from
+     * the cookie the dev tools write — so the page hydrates drawn the way the server drew it.
+     */
+    forcedFlags?: Record<string, boolean>;
     onInitStateManager?: (instance: RuntimeStateInstance) => void;
     onInitEventBridge?: (instance: EventBridgeContextValue) => void;
 };
-declare const App: ({ className, children, webKey, server, renderMode, routing, debugMode: debugModeProp, themeScope, theme, state, ...sdkProps }: AppProps) => import('react').JSX.Element;
+declare const App: ({ className, children, webKey, server, renderMode, routing, debugMode: debugModeProp, themeScope, theme, state, forcedFlags, ...sdkProps }: AppProps) => import('react').JSX.Element;
 export default App;

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { default as sdkComponents } from './modules/Element';
 import { default as ComponentProvider } from '@plitzi/sdk-elements/Component/ComponentProvider';
+import { default as useFlag } from '@plitzi/sdk-elements/dataSource/useFlag';
 import { default as withElement } from '@plitzi/sdk-elements/Element/hocs/withElement';
 import { default as useElement } from '@plitzi/sdk-elements/Element/hooks/useElement';
 import { default as useRscData } from '@plitzi/sdk-elements/Element/hooks/useRscData';
@@ -71,6 +72,19 @@ export type PlitziSdkProps = {
     debugMode?: boolean;
     /** What the server ran to build this page, for the dev-tools. Only ever sent to a page allowed to debug them. */
     actionRuns?: ActionRunSummary[];
+    /**
+     * The feature flags this embedding decides, by name: `{ newCheckout: true }`. Above whatever the space and the server
+     * rendering it say, below a tester with the dev tools. Only for flags the space declares — anything else is ignored,
+     * with a warning in the console.
+     */
+    flags?: Record<string, boolean>;
+    /** Set by the server that rendered this page: the flags its deployment decides (`createServer({ flags })`). */
+    serverFlags?: Record<string, boolean>;
+    /**
+     * Set by the server that rendered this page for somebody allowed to debug it: the flags a tester forced, read from
+     * the cookie the dev tools write — so the page hydrates drawn the way the server drew it.
+     */
+    forcedFlags?: Record<string, boolean>;
     /**
      * Set by the server that rendered this page: `offlineData.style.cache` was left out of the payload because the
      * page's own stylesheet holds it, and `render()` reads it back from there before hydrating.
@@ -119,7 +133,7 @@ declare const PlitziSdk: {
 };
 type PlitziServiceContextValue = BasePlitziServiceContextValue<InstanceType<typeof EventBridge>, InstanceType<typeof InteractionsManager>>;
 declare const usePlitziServiceContext: () => PlitziServiceContextValue;
-export { track, useSdkStore as useStore, ComponentProvider, ComponentContext, usePlitziServiceContext, PlitziServiceProvider, RootElement, withElement, JsxManager, PluginManager, sdkComponents, PluginRemote, ReplicaProvider, useElement, useRscData, useRscRefresh, useChannel };
+export { track, useSdkStore as useStore, ComponentProvider, ComponentContext, usePlitziServiceContext, PlitziServiceProvider, RootElement, withElement, JsxManager, PluginManager, sdkComponents, PluginRemote, ReplicaProvider, useElement, useRscData, useRscRefresh, useChannel, useFlag };
 export type { AnalyticsConfig, ElementContextValue, Element, Schema, Style, ComponentPlugin, ComponentPluginFC, PlitziServiceContextValue, OfflineDataRaw, InteractionCallback, InteractionCallbackParamValues, PluginDeclaration, ChannelHandle, RealtimeMember, RealtimeMessage };
 export declare const version: string;
 export declare const getStateManager: () => RuntimeStateInstance;

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

@@ -20,6 +20,12 @@ export type AppMainProps = {
     overQuota?: boolean;
     analytics?: AnalyticsConfig;
     state?: Record<string, unknown>;
+    /** The flags this embedding decides — see `PlitziSdkProps`. */
+    flags?: Record<string, boolean>;
+    /** The flags the rendering server decides — see `PlitziSdkProps`. */
+    serverFlags?: Record<string, boolean>;
+    /** The flags a tester forced, already settled against whether this page may debug. */
+    forcedFlags?: Record<string, boolean>;
     /** What the embedding application hands this space — see `PlitziSdkProps`. */
     hostData?: Record<string, unknown>;
     /** What it is willing to be asked to do — see `PlitziSdkProps`. */
@@ -27,5 +33,5 @@ export type AppMainProps = {
     onInitStateManager?: (instance: RuntimeStateInstance) => void;
     onInitEventBridge?: (instance: EventBridgeContextValue) => void;
 };
-declare const AppMain: ({ revision, webKey, webId, environment, currentPageId, server, isHydrating, offlineMode, offlineData, offlineDataType, instanceId, renderMode, sdkStylePath, sdkDevToolsStylePath, previewMode, debugMode, overQuota, analytics, onInitEventBridge, hostData, hostActions, onInitStateManager, ...sdkProps }: AppMainProps) => import('react').JSX.Element;
+declare const AppMain: ({ revision, webKey, webId, environment, currentPageId, server, isHydrating, offlineMode, offlineData, offlineDataType, instanceId, renderMode, sdkStylePath, sdkDevToolsStylePath, previewMode, debugMode, overQuota, analytics, onInitEventBridge, hostData, hostActions, flags, serverFlags, forcedFlags, onInitStateManager, ...sdkProps }: AppMainProps) => import('react').JSX.Element;
 export default AppMain;

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

@@ -15,6 +15,10 @@ export type ThemedRootProps = {
  *
  * `system` writes nothing, here as everywhere else: with no class the space inherits whatever the host document
  * settled on, which for an embedded surface is the right default.
+ *
+ * It also says when the page is interactive: `data-hydrated` appears once React has taken over the server's markup
+ * (at once for a page rendered in the browser). A space's CSS keys decorative motion that repaints every frame off it
+ * — `[data-hydrated] .glow { animation-play-state: running; }` — so the load has the main thread to itself.
  */
 declare const ThemedRoot: ({ className, scoped, children }: ThemedRootProps) => import('react').JSX.Element;
 export default ThemedRoot;

package/dist/modules/Element/elements/PlitziSdk/index.d.ts

@@ -25,7 +25,7 @@ declare const PlitziSdk: {
             canSelect: boolean;
             canDragDrop: boolean;
             canMove: boolean;
-            canTemplate: boolean;
+            canSnippet: boolean;
             itemsAllowed: never[];
             itemsNotAllowed: never[];
         };

package/dist/modules/Navigation/useScrollToHash.d.ts

@@ -0,0 +1,16 @@
+/** How long a fragment waits for its element: a section behind a provider appears once its data does. */
+export declare const HASH_WAIT_MS = 3000;
+/**
+ * Lands on the element a URL's `#fragment` names, after each navigation that carries one — on arrival too.
+ *
+ * The browser does this by itself only for a page it loaded whole, and only for what is in it at that moment: a
+ * client-side navigation never asks it to, and a section that renders once its data arrives is not there yet. So the
+ * element is looked for now and, if absent, as the page fills in, for {@link HASH_WAIT_MS}; somebody who scrolls in the
+ * meantime has gone somewhere else, and is left there. `navigationKey` makes a second click on the same link land again.
+ */
+declare const useScrollToHash: ({ hash, navigationKey, enabled }: {
+    hash: string;
+    navigationKey?: string;
+    enabled: boolean;
+}) => void;
+export default useScrollToHash;